import typing

import os

import cairo
from gi.repository import Gdk
from gi.repository import GdkPixbuf
from gi.repository import gi
from gi.repository import Gio
from gi.repository import GLib
from gi.repository import GObject
from gi.repository import Graphene
from gi.repository import Gsk
from gi.repository import Pango
from typing_extensions import Self

T = typing.TypeVar("T")
CellRendererT = typing.TypeVar(
    "CellRendererT",
    CellRendererCombo,
    CellRendererPixbuf,
    CellRendererProgress,
    CellRendererSpin,
    CellRendererSpinner,
    CellRendererText,
    CellRendererToggle,
)
WidgetT = typing.TypeVar("WidgetT", bound=Widget)
_SomeSurface = typing.TypeVar("_SomeSurface", bound=cairo.Surface)

ACCESSIBLE_ATTRIBUTE_BACKGROUND: str = "bg-color"
ACCESSIBLE_ATTRIBUTE_FAMILY: str = "family-name"
ACCESSIBLE_ATTRIBUTE_FOREGROUND: str = "fg-color"
ACCESSIBLE_ATTRIBUTE_OVERLINE: str = "overline"
ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE: str = "none"
ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE: str = "single"
ACCESSIBLE_ATTRIBUTE_SIZE: str = "size"
ACCESSIBLE_ATTRIBUTE_STRETCH: str = "stretch"
ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED: str = "condensed"
ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED: str = "expanded"
ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED: str = "extra_condensed"
ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED: str = "extra_expanded"
ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL: str = "normal"
ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED: str = "semi_condensed"
ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED: str = "semi_expanded"
ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED: str = "ultra_condensed"
ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED: str = "ultra_expanded"
ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH: str = "strikethrough"
ACCESSIBLE_ATTRIBUTE_STYLE: str = "style"
ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC: str = "italic"
ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL: str = "normal"
ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE: str = "oblique"
ACCESSIBLE_ATTRIBUTE_UNDERLINE: str = "underline"
ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE: str = "double"
ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR: str = "error"
ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE: str = "none"
ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE: str = "single"
ACCESSIBLE_ATTRIBUTE_VARIANT: str = "variant"
ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS: str = "all-petite-caps"
ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS: str = "all-small-caps"
ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS: str = "petite-caps"
ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS: str = "small-caps"
ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS: str = "title-caps"
ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE: str = "unicase"
ACCESSIBLE_ATTRIBUTE_WEIGHT: str = "weight"
ACCESSIBLE_VALUE_UNDEFINED: int = -1
BINARY_AGE: int = 2003
IM_MODULE_EXTENSION_POINT_NAME: str = "gtk-im-module"
INPUT_ERROR: int = -1
INTERFACE_AGE: int = 3
INVALID_LIST_POSITION: int = 4294967295
LEVEL_BAR_OFFSET_FULL: str = "full"
LEVEL_BAR_OFFSET_HIGH: str = "high"
LEVEL_BAR_OFFSET_LOW: str = "low"
MAJOR_VERSION: int = 4
MAX_COMPOSE_LEN: int = 7
MEDIA_FILE_EXTENSION_POINT_NAME: str = "gtk-media-file"
MICRO_VERSION: int = 3
MINOR_VERSION: int = 20
PAPER_NAME_A3: str = "iso_a3"
PAPER_NAME_A4: str = "iso_a4"
PAPER_NAME_A5: str = "iso_a5"
PAPER_NAME_B5: str = "iso_b5"
PAPER_NAME_EXECUTIVE: str = "na_executive"
PAPER_NAME_LEGAL: str = "na_legal"
PAPER_NAME_LETTER: str = "na_letter"
PRINT_SETTINGS_COLLATE: str = "collate"
PRINT_SETTINGS_DEFAULT_SOURCE: str = "default-source"
PRINT_SETTINGS_DITHER: str = "dither"
PRINT_SETTINGS_DUPLEX: str = "duplex"
PRINT_SETTINGS_FINISHINGS: str = "finishings"
PRINT_SETTINGS_MEDIA_TYPE: str = "media-type"
PRINT_SETTINGS_NUMBER_UP: str = "number-up"
PRINT_SETTINGS_NUMBER_UP_LAYOUT: str = "number-up-layout"
PRINT_SETTINGS_N_COPIES: str = "n-copies"
PRINT_SETTINGS_ORIENTATION: str = "orientation"
PRINT_SETTINGS_OUTPUT_BASENAME: str = "output-basename"
PRINT_SETTINGS_OUTPUT_BIN: str = "output-bin"
PRINT_SETTINGS_OUTPUT_DIR: str = "output-dir"
PRINT_SETTINGS_OUTPUT_FILE_FORMAT: str = "output-file-format"
PRINT_SETTINGS_OUTPUT_URI: str = "output-uri"
PRINT_SETTINGS_PAGE_RANGES: str = "page-ranges"
PRINT_SETTINGS_PAGE_SET: str = "page-set"
PRINT_SETTINGS_PAPER_FORMAT: str = "paper-format"
PRINT_SETTINGS_PAPER_HEIGHT: str = "paper-height"
PRINT_SETTINGS_PAPER_WIDTH: str = "paper-width"
PRINT_SETTINGS_PRINTER: str = "printer"
PRINT_SETTINGS_PRINTER_LPI: str = "printer-lpi"
PRINT_SETTINGS_PRINT_PAGES: str = "print-pages"
PRINT_SETTINGS_QUALITY: str = "quality"
PRINT_SETTINGS_RESOLUTION: str = "resolution"
PRINT_SETTINGS_RESOLUTION_X: str = "resolution-x"
PRINT_SETTINGS_RESOLUTION_Y: str = "resolution-y"
PRINT_SETTINGS_REVERSE: str = "reverse"
PRINT_SETTINGS_SCALE: str = "scale"
PRINT_SETTINGS_USE_COLOR: str = "use-color"
PRINT_SETTINGS_WIN32_DRIVER_EXTRA: str = "win32-driver-extra"
PRINT_SETTINGS_WIN32_DRIVER_VERSION: str = "win32-driver-version"
PRIORITY_RESIZE: int = 110
STYLE_PROVIDER_PRIORITY_APPLICATION: int = 600
STYLE_PROVIDER_PRIORITY_FALLBACK: int = 1
STYLE_PROVIDER_PRIORITY_SETTINGS: int = 400
STYLE_PROVIDER_PRIORITY_THEME: int = 200
STYLE_PROVIDER_PRIORITY_USER: int = 800
TEXT_VIEW_PRIORITY_VALIDATE: int = 125
TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: int = -1
TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: int = -2

def accelerator_get_default_mod_mask() -> Gdk.ModifierType: ...
def accelerator_get_label(
    accelerator_key: int, accelerator_mods: Gdk.ModifierType
) -> str: ...
def accelerator_get_label_with_keycode(
    display: typing.Optional[Gdk.Display],
    accelerator_key: int,
    keycode: int,
    accelerator_mods: Gdk.ModifierType,
) -> str: ...
def accelerator_name(
    accelerator_key: int, accelerator_mods: Gdk.ModifierType
) -> str: ...
def accelerator_name_with_keycode(
    display: typing.Optional[Gdk.Display],
    accelerator_key: int,
    keycode: int,
    accelerator_mods: Gdk.ModifierType,
) -> str: ...
def accelerator_parse(
    accelerator: str,
) -> typing.Tuple[bool, int, Gdk.ModifierType]: ...
def accelerator_parse_with_keycode(
    accelerator: str, display: typing.Optional[Gdk.Display] = None
) -> typing.Tuple[bool, int, list[int], Gdk.ModifierType]: ...
def accelerator_valid(keyval: int, modifiers: Gdk.ModifierType) -> bool: ...
def accessible_property_init_value(
    property: AccessibleProperty, value: typing.Any
) -> None: ...
def accessible_relation_init_value(
    relation: AccessibleRelation, value: typing.Any
) -> None: ...
def accessible_state_init_value(state: AccessibleState, value: typing.Any) -> None: ...
def bitset_iter_init_at(
    set: Bitset, target: int
) -> typing.Tuple[bool, BitsetIter, int]: ...
def bitset_iter_init_first(set: Bitset) -> typing.Tuple[bool, BitsetIter, int]: ...
def bitset_iter_init_last(set: Bitset) -> typing.Tuple[bool, BitsetIter, int]: ...
def builder_error_quark() -> int: ...
def check_version(
    required_major: int, required_minor: int, required_micro: int
) -> typing.Optional[str]: ...
def constraint_vfl_parser_error_quark() -> int: ...
def css_parser_error_quark() -> int: ...
def css_parser_warning_quark() -> int: ...
def dialog_error_quark() -> int: ...
def disable_portals() -> None: ...
def disable_setlocale() -> None: ...
def distribute_natural_allocation(
    extra_space: int, sizes: typing.Sequence[RequestedSize]
) -> int: ...
def editable_delegate_get_property(
    object: GObject.Object, prop_id: int, value: typing.Any, pspec: GObject.ParamSpec
) -> bool: ...
def editable_delegate_set_property(
    object: GObject.Object, prop_id: int, value: typing.Any, pspec: GObject.ParamSpec
) -> bool: ...
def editable_install_properties(
    object_class: GObject.ObjectClass, first_prop: int
) -> int: ...
def enumerate_printers(
    func: typing.Callable[..., bool], wait: bool, *data: typing.Any
) -> None: ...
def file_chooser_error_quark() -> int: ...
def get_binary_age() -> int: ...
def get_debug_flags() -> DebugFlags: ...
def get_default_language() -> Pango.Language: ...
def get_interface_age() -> int: ...
def get_locale_direction() -> TextDirection: ...
def get_major_version() -> int: ...
def get_micro_version() -> int: ...
def get_minor_version() -> int: ...
def hsv_to_rgb(h: float, s: float, v: float) -> typing.Tuple[float, float, float]: ...
def icon_theme_error_quark() -> int: ...
def init() -> None: ...
def init_check() -> bool: ...
def is_initialized() -> bool: ...
def native_get_for_surface(surface: Gdk.Surface) -> typing.Optional[Native]: ...
def paper_size_get_default() -> str: ...
def paper_size_get_paper_sizes(include_custom: bool) -> list[PaperSize]: ...
def param_spec_expression(
    name: str, nick: str, blurb: str, flags: GObject.ParamFlags
) -> GObject.ParamSpec: ...
def print_error_quark() -> int: ...
def print_run_page_setup_dialog(
    parent: typing.Optional[Window],
    page_setup: typing.Optional[PageSetup],
    settings: PrintSettings,
) -> PageSetup: ...
def print_run_page_setup_dialog_async(
    parent: typing.Optional[Window],
    page_setup: typing.Optional[PageSetup],
    settings: PrintSettings,
    done_cb: typing.Callable[..., None],
    *data: typing.Any,
) -> None: ...
def recent_manager_error_quark() -> int: ...
def render_activity(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_arrow(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    angle: float,
    x: float,
    y: float,
    size: float,
) -> None: ...
def render_background(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_check(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_expander(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_focus(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_frame(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_handle(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def render_icon(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    texture: Gdk.Texture,
    x: float,
    y: float,
) -> None: ...
def render_layout(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    layout: Pango.Layout,
) -> None: ...
def render_line(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x0: float,
    y0: float,
    x1: float,
    y1: float,
) -> None: ...
def render_option(
    context: StyleContext,
    cr: cairo.Context[_SomeSurface],
    x: float,
    y: float,
    width: float,
    height: float,
) -> None: ...
def rgb_to_hsv(r: float, g: float, b: float) -> typing.Tuple[float, float, float]: ...
def set_debug_flags(flags: DebugFlags) -> None: ...
def show_uri(parent: typing.Optional[Window], uri: str, timestamp: int) -> None: ...
def show_uri_full(
    parent: typing.Optional[Window],
    uri: str,
    timestamp: int,
    cancellable: typing.Optional[Gio.Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def show_uri_full_finish(parent: Window, result: Gio.AsyncResult) -> bool: ...
def test_accessible_assertion_message_role(
    domain: str,
    file: str,
    line: int,
    func: str,
    expr: str,
    accessible: Accessible,
    expected_role: AccessibleRole,
    actual_role: AccessibleRole,
) -> None: ...
def test_accessible_has_property(
    accessible: Accessible, property: AccessibleProperty
) -> bool: ...
def test_accessible_has_relation(
    accessible: Accessible, relation: AccessibleRelation
) -> bool: ...
def test_accessible_has_role(accessible: Accessible, role: AccessibleRole) -> bool: ...
def test_accessible_has_state(
    accessible: Accessible, state: AccessibleState
) -> bool: ...
def test_list_all_types() -> list[typing.Type[typing.Any]]: ...
def test_register_all_types() -> None: ...
def test_widget_wait_for_draw(widget: Widget) -> None: ...
def tree_create_row_drag_content(
    tree_model: TreeModel, path: TreePath
) -> Gdk.ContentProvider: ...
def tree_get_row_drag_data(
    value: typing.Any,
) -> typing.Tuple[bool, TreeModel, TreePath]: ...
def tree_row_reference_deleted(proxy: GObject.Object, path: TreePath) -> None: ...
def tree_row_reference_inserted(proxy: GObject.Object, path: TreePath) -> None: ...
def value_dup_expression(value: typing.Any) -> typing.Optional[Expression]: ...
def value_get_expression(value: typing.Any) -> typing.Optional[Expression]: ...
def value_set_expression(value: typing.Any, expression: Expression) -> None: ...
def value_take_expression(
    value: typing.Any, expression: typing.Optional[Expression] = None
) -> None: ...

class ATContext(GObject.Object):
    """
    :Constructors:

    ::

        ATContext(**properties)
        create(accessible_role:Gtk.AccessibleRole, accessible:Gtk.Accessible, display:Gdk.Display) -> Gtk.ATContext or None

    Object GtkATContext

    Signals from GtkATContext:
      state-change ()

    Properties from GtkATContext:
      accessible-role -> GtkAccessibleRole: accessible-role
      accessible -> GtkAccessible: accessible
      display -> GdkDisplay: display

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        accessible: Accessible
        accessible_role: AccessibleRole
        display: Gdk.Display

    props: Props = ...
    def __init__(
        self,
        accessible: Accessible = ...,
        accessible_role: AccessibleRole = ...,
        display: Gdk.Display = ...,
    ) -> None: ...
    @classmethod
    def create(
        cls,
        accessible_role: AccessibleRole,
        accessible: Accessible,
        display: Gdk.Display,
    ) -> typing.Optional[ATContext]: ...
    def get_accessible(self) -> Accessible: ...
    def get_accessible_role(self) -> AccessibleRole: ...

class ATContextClass(GObject.GPointer): ...

class AboutDialog(
    Window, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        AboutDialog(**properties)
        new() -> Gtk.Widget

    Object GtkAboutDialog

    Signals from GtkAboutDialog:
      activate-link (gchararray) -> gboolean

    Properties from GtkAboutDialog:
      program-name -> gchararray: program-name
      version -> gchararray: version
      copyright -> gchararray: copyright
      comments -> gchararray: comments
      website -> gchararray: website
      website-label -> gchararray: website-label
      license -> gchararray: license
      system-information -> gchararray: system-information
      authors -> GStrv: authors
      documenters -> GStrv: documenters
      translator-credits -> gchararray: translator-credits
      artists -> GStrv: artists
      logo -> GdkPaintable: logo
      logo-icon-name -> gchararray: logo-icon-name
      wrap-license -> gboolean: wrap-license
      license-type -> GtkLicense: license-type

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Window.Props):
        artists: list[str]
        authors: list[str]
        comments: typing.Optional[str]
        copyright: typing.Optional[str]
        documenters: list[str]
        license: typing.Optional[str]
        license_type: License
        logo: typing.Optional[Gdk.Paintable]
        logo_icon_name: typing.Optional[str]
        program_name: typing.Optional[str]
        system_information: typing.Optional[str]
        translator_credits: typing.Optional[str]
        version: typing.Optional[str]
        website: typing.Optional[str]
        website_label: typing.Optional[str]
        wrap_license: bool
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        artists: typing.Sequence[str] = ...,
        authors: typing.Sequence[str] = ...,
        comments: typing.Optional[str] = ...,
        copyright: typing.Optional[str] = ...,
        documenters: typing.Sequence[str] = ...,
        license: typing.Optional[str] = ...,
        license_type: License = ...,
        logo: typing.Optional[Gdk.Paintable] = ...,
        logo_icon_name: typing.Optional[str] = ...,
        program_name: typing.Optional[str] = ...,
        system_information: typing.Optional[str] = ...,
        translator_credits: typing.Optional[str] = ...,
        version: typing.Optional[str] = ...,
        website: typing.Optional[str] = ...,
        website_label: str = ...,
        wrap_license: bool = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_credit_section(
        self, section_name: str, people: typing.Sequence[str]
    ) -> None: ...
    def get_artists(self) -> list[str]: ...
    def get_authors(self) -> list[str]: ...
    def get_comments(self) -> typing.Optional[str]: ...
    def get_copyright(self) -> typing.Optional[str]: ...
    def get_documenters(self) -> list[str]: ...
    def get_license(self) -> typing.Optional[str]: ...
    def get_license_type(self) -> License: ...
    def get_logo(self) -> typing.Optional[Gdk.Paintable]: ...
    def get_logo_icon_name(self) -> typing.Optional[str]: ...
    def get_program_name(self) -> typing.Optional[str]: ...
    def get_system_information(self) -> typing.Optional[str]: ...
    def get_translator_credits(self) -> typing.Optional[str]: ...
    def get_version(self) -> typing.Optional[str]: ...
    def get_website(self) -> typing.Optional[str]: ...
    def get_website_label(self) -> typing.Optional[str]: ...
    def get_wrap_license(self) -> bool: ...
    @classmethod
    def new(cls) -> AboutDialog: ...
    def set_artists(self, artists: typing.Sequence[str]) -> None: ...
    def set_authors(self, authors: typing.Sequence[str]) -> None: ...
    def set_comments(self, comments: typing.Optional[str] = None) -> None: ...
    def set_copyright(self, copyright: typing.Optional[str] = None) -> None: ...
    def set_documenters(self, documenters: typing.Sequence[str]) -> None: ...
    def set_license(self, license: typing.Optional[str] = None) -> None: ...
    def set_license_type(self, license_type: License) -> None: ...
    def set_logo(self, logo: typing.Optional[Gdk.Paintable] = None) -> None: ...
    def set_logo_icon_name(self, icon_name: typing.Optional[str] = None) -> None: ...
    def set_program_name(self, name: typing.Optional[str] = None) -> None: ...
    def set_system_information(
        self, system_information: typing.Optional[str] = None
    ) -> None: ...
    def set_translator_credits(
        self, translator_credits: typing.Optional[str] = None
    ) -> None: ...
    def set_version(self, version: typing.Optional[str] = None) -> None: ...
    def set_website(self, website: typing.Optional[str] = None) -> None: ...
    def set_website_label(self, website_label: str) -> None: ...
    def set_wrap_license(self, wrap_license: bool) -> None: ...

class Accessible(GObject.GInterface):
    """
    Interface GtkAccessible

    Signals from GObject:
      notify (GParam)
    """
    def announce(
        self, message: str, priority: AccessibleAnnouncementPriority
    ) -> None: ...
    def get_accessible_parent(self) -> typing.Optional[Accessible]: ...
    def get_accessible_role(self) -> AccessibleRole: ...
    def get_at_context(self) -> ATContext: ...
    def get_bounds(self) -> typing.Tuple[bool, int, int, int, int]: ...
    def get_first_accessible_child(self) -> typing.Optional[Accessible]: ...
    def get_next_accessible_sibling(self) -> typing.Optional[Accessible]: ...
    def get_platform_state(self, state: AccessiblePlatformState) -> bool: ...
    def reset_property(self, property: AccessibleProperty) -> None: ...
    def reset_relation(self, relation: AccessibleRelation) -> None: ...
    def reset_state(self, state: AccessibleState) -> None: ...
    def set_accessible_parent(
        self,
        parent: typing.Optional[Accessible] = None,
        next_sibling: typing.Optional[Accessible] = None,
    ) -> None: ...
    def update_next_accessible_sibling(
        self, new_sibling: typing.Optional[Accessible] = None
    ) -> None: ...
    def update_platform_state(self, state: AccessiblePlatformState) -> None: ...
    def update_property(
        self,
        properties: typing.Sequence[AccessibleProperty],
        values: typing.Sequence[typing.Any],
    ) -> None: ...
    def update_relation(
        self,
        relations: typing.Sequence[AccessibleRelation],
        values: typing.Sequence[typing.Any],
    ) -> None: ...
    def update_state(
        self,
        states: typing.Sequence[AccessibleState],
        values: typing.Sequence[typing.Any],
    ) -> None: ...

class AccessibleInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        AccessibleInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_at_context: typing.Callable[[Accessible], typing.Optional[ATContext]] = ...
    get_platform_state: typing.Callable[
        [Accessible, AccessiblePlatformState], bool
    ] = ...
    get_accessible_parent: typing.Callable[
        [Accessible], typing.Optional[Accessible]
    ] = ...
    get_first_accessible_child: typing.Callable[
        [Accessible], typing.Optional[Accessible]
    ] = ...
    get_next_accessible_sibling: typing.Callable[
        [Accessible], typing.Optional[Accessible]
    ] = ...
    get_bounds: typing.Callable[
        [Accessible], typing.Tuple[bool, int, int, int, int]
    ] = ...

class AccessibleList(GObject.GBoxed):
    """
    :Constructors:

    ::

        new_from_array(accessibles:list) -> Gtk.AccessibleList
        new_from_list(list:list) -> Gtk.AccessibleList
    """
    def get_objects(self) -> list[Accessible]: ...
    @classmethod
    def new_from_array(
        cls, accessibles: typing.Sequence[Accessible]
    ) -> AccessibleList: ...
    @classmethod
    def new_from_list(cls, list: list[Accessible]) -> AccessibleList: ...

class AccessibleRange(GObject.GInterface): ...

class AccessibleRangeInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        AccessibleRangeInterface()
    """

    g_iface: GObject.TypeInterface = ...
    set_current_value: typing.Callable[[AccessibleRange, float], bool] = ...

class AccessibleText(GObject.GInterface):
    """
    Interface GtkAccessibleText

    Signals from GObject:
      notify (GParam)
    """
    def update_caret_position(self) -> None: ...
    def update_contents(
        self, change: AccessibleTextContentChange, start: int, end: int
    ) -> None: ...
    def update_selection_bound(self) -> None: ...

class AccessibleTextInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        AccessibleTextInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_contents: typing.Callable[[AccessibleText, int, int], GLib.Bytes] = ...
    get_contents_at: typing.Callable[
        [AccessibleText, int, AccessibleTextGranularity],
        typing.Tuple[GLib.Bytes, int, int],
    ] = ...
    get_caret_position: typing.Callable[[AccessibleText], int] = ...
    get_selection: typing.Callable[
        [AccessibleText], typing.Tuple[bool, list[AccessibleTextRange]]
    ] = ...
    get_attributes: typing.Callable[
        [AccessibleText, int],
        typing.Tuple[bool, list[AccessibleTextRange], list[str], list[str]],
    ] = ...
    get_default_attributes: typing.Callable[
        [AccessibleText], typing.Tuple[list[str], list[str]]
    ] = ...
    get_extents: typing.Callable[[AccessibleText, int, int, Graphene.Rect], bool] = ...
    get_offset: typing.Callable[
        [AccessibleText, Graphene.Point], typing.Tuple[bool, int]
    ] = ...

class AccessibleTextRange(GObject.GPointer):
    """
    :Constructors:

    ::

        AccessibleTextRange()
    """

    start: int = ...
    length: int = ...

class ActionBar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ActionBar(**properties)
        new() -> Gtk.Widget

    Object GtkActionBar

    Properties from GtkActionBar:
      revealed -> gboolean: revealed

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        revealed: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        revealed: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_center_widget(self) -> typing.Optional[Widget]: ...
    def get_revealed(self) -> bool: ...
    @classmethod
    def new(cls) -> ActionBar: ...
    def pack_end(self, child: Widget) -> None: ...
    def pack_start(self, child: Widget) -> None: ...
    def remove(self, child: Widget) -> None: ...
    def set_center_widget(
        self, center_widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_revealed(self, revealed: bool) -> None: ...

class Actionable(GObject.GInterface):
    """
    Interface GtkActionable

    Signals from GObject:
      notify (GParam)
    """
    def get_action_name(self) -> typing.Optional[str]: ...
    def get_action_target_value(self) -> typing.Optional[GLib.Variant]: ...
    def set_action_name(self, action_name: typing.Optional[str] = None) -> None: ...
    def set_action_target_value(
        self, target_value: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    def set_detailed_action_name(self, detailed_action_name: str) -> None: ...

class ActionableInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ActionableInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_action_name: typing.Callable[[Actionable], typing.Optional[str]] = ...
    set_action_name: typing.Callable[[Actionable, typing.Optional[str]], None] = ...
    get_action_target_value: typing.Callable[
        [Actionable], typing.Optional[GLib.Variant]
    ] = ...
    set_action_target_value: typing.Callable[
        [Actionable, typing.Optional[GLib.Variant]], None
    ] = ...

class ActivateAction(ShortcutAction):
    """
    :Constructors:

    ::

        ActivateAction(**properties)

    Object GtkActivateAction

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get() -> ActivateAction: ...

class ActivateActionClass(GObject.GPointer): ...

class Adjustment(GObject.InitiallyUnowned):
    """
    :Constructors:

    ::

        Adjustment(**properties)
        new(value:float, lower:float, upper:float, step_increment:float, page_increment:float, page_size:float) -> Gtk.Adjustment

    Object GtkAdjustment

    Signals from GtkAdjustment:
      changed ()
      value-changed ()

    Properties from GtkAdjustment:
      value -> gdouble: value
      lower -> gdouble: lower
      upper -> gdouble: upper
      step-increment -> gdouble: step-increment
      page-increment -> gdouble: page-increment
      page-size -> gdouble: page-size

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.InitiallyUnowned.Props):
        lower: float
        page_increment: float
        page_size: float
        step_increment: float
        upper: float
        value: float

    props: Props = ...
    parent_instance: GObject.InitiallyUnowned = ...
    def __init__(
        self,
        lower: float = ...,
        page_increment: float = ...,
        page_size: float = ...,
        step_increment: float = ...,
        upper: float = ...,
        value: float = ...,
    ) -> None: ...
    def clamp_page(self, lower: float, upper: float) -> None: ...
    def configure(
        self,
        value: float,
        lower: float,
        upper: float,
        step_increment: float,
        page_increment: float,
        page_size: float,
    ) -> None: ...
    def do_changed(self) -> None: ...
    def do_value_changed(self) -> None: ...
    def get_lower(self) -> float: ...
    def get_minimum_increment(self) -> float: ...
    def get_page_increment(self) -> float: ...
    def get_page_size(self) -> float: ...
    def get_step_increment(self) -> float: ...
    def get_upper(self) -> float: ...
    def get_value(self) -> float: ...
    @classmethod
    def new(
        cls,
        value: float,
        lower: float,
        upper: float,
        step_increment: float,
        page_increment: float,
        page_size: float,
    ) -> Adjustment: ...
    def set_lower(self, lower: float) -> None: ...
    def set_page_increment(self, page_increment: float) -> None: ...
    def set_page_size(self, page_size: float) -> None: ...
    def set_step_increment(self, step_increment: float) -> None: ...
    def set_upper(self, upper: float) -> None: ...
    def set_value(self, value: float) -> None: ...

class AdjustmentClass(GObject.GPointer):
    """
    :Constructors:

    ::

        AdjustmentClass()
    """

    parent_class: GObject.InitiallyUnownedClass = ...
    changed: typing.Callable[[Adjustment], None] = ...
    value_changed: typing.Callable[[Adjustment], None] = ...

class AlertDialog(GObject.Object):
    """
    :Constructors:

    ::

        AlertDialog(**properties)

    Object GtkAlertDialog

    Properties from GtkAlertDialog:
      modal -> gboolean: modal
      message -> gchararray: message
      detail -> gchararray: detail
      buttons -> GStrv: buttons
      cancel-button -> gint: cancel-button
      default-button -> gint: default-button

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        buttons: typing.Optional[list[str]]
        cancel_button: int
        default_button: int
        detail: str
        message: str
        modal: bool

    props: Props = ...
    def __init__(
        self,
        buttons: typing.Sequence[str] = ...,
        cancel_button: int = ...,
        default_button: int = ...,
        detail: str = ...,
        message: str = ...,
        modal: bool = ...,
    ) -> None: ...
    def choose(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def choose_finish(self, result: Gio.AsyncResult) -> int: ...
    def get_buttons(self) -> typing.Optional[list[str]]: ...
    def get_cancel_button(self) -> int: ...
    def get_default_button(self) -> int: ...
    def get_detail(self) -> str: ...
    def get_message(self) -> str: ...
    def get_modal(self) -> bool: ...
    def set_buttons(self, labels: typing.Sequence[str]) -> None: ...
    def set_cancel_button(self, button: int) -> None: ...
    def set_default_button(self, button: int) -> None: ...
    def set_detail(self, detail: str) -> None: ...
    def set_message(self, message: str) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def show(self, parent: typing.Optional[Window] = None) -> None: ...

class AlertDialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        AlertDialogClass()
    """

    parent_class: GObject.ObjectClass = ...

class AlternativeTrigger(ShortcutTrigger):
    """
    :Constructors:

    ::

        AlternativeTrigger(**properties)
        new(first:Gtk.ShortcutTrigger, second:Gtk.ShortcutTrigger) -> Gtk.ShortcutTrigger

    Object GtkAlternativeTrigger

    Properties from GtkAlternativeTrigger:
      first -> GtkShortcutTrigger: first
      second -> GtkShortcutTrigger: second

    Signals from GObject:
      notify (GParam)
    """
    class Props(ShortcutTrigger.Props):
        first: ShortcutTrigger
        second: ShortcutTrigger

    props: Props = ...
    def __init__(
        self, first: ShortcutTrigger = ..., second: ShortcutTrigger = ...
    ) -> None: ...
    def get_first(self) -> ShortcutTrigger: ...
    def get_second(self) -> ShortcutTrigger: ...
    @classmethod
    def new(
        cls, first: ShortcutTrigger, second: ShortcutTrigger
    ) -> AlternativeTrigger: ...

class AlternativeTriggerClass(GObject.GPointer): ...

# override
class AnyFilter(MultiFilter, Gio.ListModel[typing.Any], Buildable):
    """
    :Constructors:

    ::

        AnyFilter(**properties)
        new() -> Gtk.AnyFilter

    Object GtkAnyFilter

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Properties from GtkMultiFilter:
      item-type -> GType: item-type
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(MultiFilter.Props):
        item_type: typing.Type[typing.Any]
        n_items: int

    props: Props = ...
    @classmethod
    def new(cls) -> AnyFilter: ...

class AnyFilterClass(GObject.GPointer): ...

class AppChooser(GObject.GInterface):
    """
    Interface GtkAppChooser

    Signals from GObject:
      notify (GParam)
    """
    def get_app_info(self) -> typing.Optional[Gio.AppInfo]: ...
    def get_content_type(self) -> str: ...
    def refresh(self) -> None: ...

class AppChooserButton(Widget, Accessible, AppChooser, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        AppChooserButton(**properties)
        new(content_type:str) -> Gtk.Widget

    Object GtkAppChooserButton

    Signals from GtkAppChooserButton:
      changed ()
      custom-item-activated (gchararray)
      activate ()

    Properties from GtkAppChooserButton:
      show-dialog-item -> gboolean: show-dialog-item
      show-default-item -> gboolean: show-default-item
      heading -> gchararray: heading
      modal -> gboolean: modal

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        heading: typing.Optional[str]
        modal: bool
        show_default_item: bool
        show_dialog_item: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        content_type: str

    props: Props = ...
    def __init__(
        self,
        heading: str = ...,
        modal: bool = ...,
        show_default_item: bool = ...,
        show_dialog_item: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        content_type: str = ...,
    ) -> None: ...
    def append_custom_item(self, name: str, label: str, icon: Gio.Icon) -> None: ...
    def append_separator(self) -> None: ...
    def get_heading(self) -> typing.Optional[str]: ...
    def get_modal(self) -> bool: ...
    def get_show_default_item(self) -> bool: ...
    def get_show_dialog_item(self) -> bool: ...
    @classmethod
    def new(cls, content_type: str) -> AppChooserButton: ...
    def set_active_custom_item(self, name: str) -> None: ...
    def set_heading(self, heading: str) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_show_default_item(self, setting: bool) -> None: ...
    def set_show_dialog_item(self, setting: bool) -> None: ...

class AppChooserDialog(
    Dialog,
    Accessible,
    AppChooser,
    Buildable,
    ConstraintTarget,
    Native,
    Root,
    ShortcutManager,
):
    """
    :Constructors:

    ::

        AppChooserDialog(**properties)
        new(parent:Gtk.Window=None, flags:Gtk.DialogFlags, file:Gio.File) -> Gtk.Widget
        new_for_content_type(parent:Gtk.Window=None, flags:Gtk.DialogFlags, content_type:str) -> Gtk.Widget

    Object GtkAppChooserDialog

    Properties from GtkAppChooserDialog:
      gfile -> GFile: gfile
      heading -> gchararray: heading

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Dialog.Props):
        gfile: Gio.File
        heading: typing.Optional[str]
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        content_type: str
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        gfile: Gio.File = ...,
        heading: str = ...,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        content_type: str = ...,
    ) -> None: ...
    def get_heading(self) -> typing.Optional[str]: ...
    def get_widget(self) -> Widget: ...
    @classmethod
    def new(
        cls, parent: typing.Optional[Window], flags: DialogFlags, file: Gio.File
    ) -> AppChooserDialog: ...
    @classmethod
    def new_for_content_type(
        cls, parent: typing.Optional[Window], flags: DialogFlags, content_type: str
    ) -> AppChooserDialog: ...
    def set_heading(self, heading: str) -> None: ...

class AppChooserWidget(Widget, Accessible, AppChooser, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        AppChooserWidget(**properties)
        new(content_type:str) -> Gtk.Widget

    Object GtkAppChooserWidget

    Signals from GtkAppChooserWidget:
      application-selected (GAppInfo)
      application-activated (GAppInfo)

    Properties from GtkAppChooserWidget:
      show-default -> gboolean: show-default
      show-recommended -> gboolean: show-recommended
      show-fallback -> gboolean: show-fallback
      show-other -> gboolean: show-other
      show-all -> gboolean: show-all
      default-text -> gchararray: default-text

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        default_text: typing.Optional[str]
        show_all: bool
        show_default: bool
        show_fallback: bool
        show_other: bool
        show_recommended: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        content_type: str

    props: Props = ...
    def __init__(
        self,
        default_text: str = ...,
        show_all: bool = ...,
        show_default: bool = ...,
        show_fallback: bool = ...,
        show_other: bool = ...,
        show_recommended: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        content_type: str = ...,
    ) -> None: ...
    def get_default_text(self) -> typing.Optional[str]: ...
    def get_show_all(self) -> bool: ...
    def get_show_default(self) -> bool: ...
    def get_show_fallback(self) -> bool: ...
    def get_show_other(self) -> bool: ...
    def get_show_recommended(self) -> bool: ...
    @classmethod
    def new(cls, content_type: str) -> AppChooserWidget: ...
    def set_default_text(self, text: str) -> None: ...
    def set_show_all(self, setting: bool) -> None: ...
    def set_show_default(self, setting: bool) -> None: ...
    def set_show_fallback(self, setting: bool) -> None: ...
    def set_show_other(self, setting: bool) -> None: ...
    def set_show_recommended(self, setting: bool) -> None: ...

class Application(Gio.Application, Gio.ActionGroup, Gio.ActionMap):
    """
    :Constructors:

    ::

        Application(**properties)
        new(application_id:str=None, flags:Gio.ApplicationFlags) -> Gtk.Application

    Object GtkApplication

    Signals from GtkApplication:
      window-added (GtkWindow)
      window-removed (GtkWindow)
      query-end ()

    Properties from GtkApplication:
      register-session -> gboolean: register-session
      screensaver-active -> gboolean: screensaver-active
      menubar -> GMenuModel: menubar
      active-window -> GtkWindow: active-window

    Signals from GActionGroup:
      action-added (gchararray)
      action-removed (gchararray)
      action-enabled-changed (gchararray, gboolean)
      action-state-changed (gchararray, GVariant)

    Signals from GApplication:
      activate ()
      startup ()
      shutdown ()
      open (gpointer, gint, gchararray)
      command-line (GApplicationCommandLine) -> gint
      handle-local-options (GVariantDict) -> gint
      name-lost () -> gboolean

    Properties from GApplication:
      application-id -> gchararray: application-id
      version -> gchararray: version
      flags -> GApplicationFlags: flags
      resource-base-path -> gchararray: resource-base-path
      is-registered -> gboolean: is-registered
      is-remote -> gboolean: is-remote
      inactivity-timeout -> guint: inactivity-timeout
      action-group -> GActionGroup: action-group
      is-busy -> gboolean: is-busy

    Signals from GActionGroup:
      action-added (gchararray)
      action-removed (gchararray)
      action-enabled-changed (gchararray, gboolean)
      action-state-changed (gchararray, GVariant)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Gio.Application.Props):
        active_window: typing.Optional[Window]
        menubar: typing.Optional[Gio.MenuModel]
        register_session: bool
        screensaver_active: bool
        application_id: typing.Optional[str]
        flags: Gio.ApplicationFlags
        inactivity_timeout: int
        is_busy: bool
        is_registered: bool
        is_remote: bool
        resource_base_path: typing.Optional[str]
        version: typing.Optional[str]
        action_group: typing.Optional[Gio.ActionGroup]

    props: Props = ...
    parent_instance: Gio.Application = ...
    def __init__(
        self,
        menubar: typing.Optional[Gio.MenuModel] = ...,
        register_session: bool = ...,
        action_group: typing.Optional[Gio.ActionGroup] = ...,
        application_id: typing.Optional[str] = ...,
        flags: Gio.ApplicationFlags = ...,
        inactivity_timeout: int = ...,
        resource_base_path: typing.Optional[str] = ...,
        version: str = ...,
    ) -> None: ...
    def add_window(self, window: Window) -> None: ...
    def do_window_added(self, window: Window) -> None: ...
    def do_window_removed(self, window: Window) -> None: ...
    def get_accels_for_action(self, detailed_action_name: str) -> list[str]: ...
    def get_actions_for_accel(self, accel: str) -> list[str]: ...
    def get_active_window(self) -> typing.Optional[Window]: ...
    def get_menu_by_id(self, id: str) -> typing.Optional[Gio.Menu]: ...
    def get_menubar(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_window_by_id(self, id: int) -> typing.Optional[Window]: ...
    def get_windows(self) -> list[Window]: ...
    def inhibit(
        self,
        window: typing.Optional[Window],
        flags: ApplicationInhibitFlags,
        reason: typing.Optional[str] = None,
    ) -> int: ...
    def list_action_descriptions(self) -> list[str]: ...
    @classmethod
    def new(
        cls, application_id: typing.Optional[str], flags: Gio.ApplicationFlags
    ) -> Application: ...
    def remove_window(self, window: Window) -> None: ...
    def set_accels_for_action(
        self, detailed_action_name: str, accels: typing.Sequence[str]
    ) -> None: ...
    def set_menubar(self, menubar: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def uninhibit(self, cookie: int) -> None: ...

class ApplicationClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ApplicationClass()
    """

    parent_class: Gio.ApplicationClass = ...
    window_added: typing.Callable[[Application, Window], None] = ...
    window_removed: typing.Callable[[Application, Window], None] = ...
    padding: list[None] = ...

class ApplicationWindow(
    Window,
    Gio.ActionGroup,
    Gio.ActionMap,
    Accessible,
    Buildable,
    ConstraintTarget,
    Native,
    Root,
    ShortcutManager,
):
    """
    :Constructors:

    ::

        ApplicationWindow(**properties)
        new(application:Gtk.Application) -> Gtk.Widget

    Object GtkApplicationWindow

    Properties from GtkApplicationWindow:
      show-menubar -> gboolean: show-menubar

    Signals from GActionGroup:
      action-added (gchararray)
      action-removed (gchararray)
      action-enabled-changed (gchararray, gboolean)
      action-state-changed (gchararray, GVariant)

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Window.Props):
        show_menubar: bool
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    parent_instance: Window = ...
    def __init__(
        self,
        show_menubar: bool = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_help_overlay(self) -> typing.Optional[ShortcutsWindow]: ...
    def get_id(self) -> int: ...
    def get_show_menubar(self) -> bool: ...
    @classmethod
    def new(cls, application: Application) -> ApplicationWindow: ...
    def set_help_overlay(
        self, help_overlay: typing.Optional[ShortcutsWindow] = None
    ) -> None: ...
    def set_show_menubar(self, show_menubar: bool) -> None: ...

class ApplicationWindowClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ApplicationWindowClass()
    """

    parent_class: WindowClass = ...
    padding: list[None] = ...

class AspectFrame(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        AspectFrame(**properties)
        new(xalign:float, yalign:float, ratio:float, obey_child:bool) -> Gtk.Widget

    Object GtkAspectFrame

    Properties from GtkAspectFrame:
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      ratio -> gfloat: ratio
      obey-child -> gboolean: obey-child
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        obey_child: bool
        ratio: float
        xalign: float
        yalign: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        obey_child: bool = ...,
        ratio: float = ...,
        xalign: float = ...,
        yalign: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_obey_child(self) -> bool: ...
    def get_ratio(self) -> float: ...
    def get_xalign(self) -> float: ...
    def get_yalign(self) -> float: ...
    @classmethod
    def new(
        cls, xalign: float, yalign: float, ratio: float, obey_child: bool
    ) -> AspectFrame: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_obey_child(self, obey_child: bool) -> None: ...
    def set_ratio(self, ratio: float) -> None: ...
    def set_xalign(self, xalign: float) -> None: ...
    def set_yalign(self, yalign: float) -> None: ...

class Assistant(
    Window, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        Assistant(**properties)
        new() -> Gtk.Widget

    Object GtkAssistant

    Signals from GtkAssistant:
      close ()
      cancel ()
      prepare (GtkWidget)
      apply ()
      escape ()

    Properties from GtkAssistant:
      use-header-bar -> gint: use-header-bar
      pages -> GListModel: pages

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(Window.Props):
        pages: Gio.ListModel[typing.Any]
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_action_widget(self, child: Widget) -> None: ...
    def append_page(self, page: Widget) -> int: ...
    def commit(self) -> None: ...
    def get_current_page(self) -> int: ...
    def get_n_pages(self) -> int: ...
    def get_nth_page(self, page_num: int) -> typing.Optional[Widget]: ...
    def get_page(self, child: Widget) -> AssistantPage: ...
    def get_page_complete(self, page: Widget) -> bool: ...
    def get_page_title(self, page: Widget) -> str: ...
    def get_page_type(self, page: Widget) -> AssistantPageType: ...
    # override
    def get_pages(self) -> Gio.ListModel[typing.Any]: ...
    def insert_page(self, page: Widget, position: int) -> int: ...
    @classmethod
    def new(cls) -> Assistant: ...
    def next_page(self) -> None: ...
    def prepend_page(self, page: Widget) -> int: ...
    def previous_page(self) -> None: ...
    def remove_action_widget(self, child: Widget) -> None: ...
    def remove_page(self, page_num: int) -> None: ...
    def set_current_page(self, page_num: int) -> None: ...
    def set_forward_page_func(
        self,
        page_func: typing.Optional[typing.Callable[..., int]] = None,
        *data: typing.Any,
    ) -> None: ...
    def set_page_complete(self, page: Widget, complete: bool) -> None: ...
    def set_page_title(self, page: Widget, title: str) -> None: ...
    def set_page_type(self, page: Widget, type: AssistantPageType) -> None: ...
    def update_buttons_state(self) -> None: ...

class AssistantPage(GObject.Object):
    """
    :Constructors:

    ::

        AssistantPage(**properties)

    Object GtkAssistantPage

    Properties from GtkAssistantPage:
      child -> GtkWidget: child
      page-type -> GtkAssistantPageType: page-type
      title -> gchararray: title
      complete -> gboolean: complete

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        child: Widget
        complete: bool
        page_type: AssistantPageType
        title: str

    props: Props = ...
    def __init__(
        self,
        child: Widget = ...,
        complete: bool = ...,
        page_type: AssistantPageType = ...,
        title: str = ...,
    ) -> None: ...
    def get_child(self) -> Widget: ...

class BinLayout(LayoutManager):
    """
    :Constructors:

    ::

        BinLayout(**properties)
        new() -> Gtk.LayoutManager

    Object GtkBinLayout

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(cls) -> BinLayout: ...

class BinLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BinLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class Bitset(GObject.GBoxed):
    """
    :Constructors:

    ::

        new_empty() -> Gtk.Bitset
        new_range(start:int, n_items:int) -> Gtk.Bitset
    """
    def add(self, value: int) -> bool: ...
    def add_range(self, start: int, n_items: int) -> None: ...
    def add_range_closed(self, first: int, last: int) -> None: ...
    def add_rectangle(
        self, start: int, width: int, height: int, stride: int
    ) -> None: ...
    def contains(self, value: int) -> bool: ...
    def copy(self) -> Bitset: ...
    def difference(self, other: Bitset) -> None: ...
    def equals(self, other: Bitset) -> bool: ...
    def get_maximum(self) -> int: ...
    def get_minimum(self) -> int: ...
    def get_nth(self, nth: int) -> int: ...
    def get_size(self) -> int: ...
    def get_size_in_range(self, first: int, last: int) -> int: ...
    def intersect(self, other: Bitset) -> None: ...
    def is_empty(self) -> bool: ...
    @classmethod
    def new_empty(cls) -> Bitset: ...
    @classmethod
    def new_range(cls, start: int, n_items: int) -> Bitset: ...
    def ref(self) -> Bitset: ...
    def remove(self, value: int) -> bool: ...
    def remove_all(self) -> None: ...
    def remove_range(self, start: int, n_items: int) -> None: ...
    def remove_range_closed(self, first: int, last: int) -> None: ...
    def remove_rectangle(
        self, start: int, width: int, height: int, stride: int
    ) -> None: ...
    def shift_left(self, amount: int) -> None: ...
    def shift_right(self, amount: int) -> None: ...
    def splice(self, position: int, removed: int, added: int) -> None: ...
    def subtract(self, other: Bitset) -> None: ...
    def union(self, other: Bitset) -> None: ...
    def unref(self) -> None: ...

class BitsetIter(GObject.GBoxed):
    """
    :Constructors:

    ::

        BitsetIter()
    """

    private_data: list[None] = ...
    def get_value(self) -> int: ...
    @staticmethod
    def init_at(set: Bitset, target: int) -> typing.Tuple[bool, BitsetIter, int]: ...
    @staticmethod
    def init_first(set: Bitset) -> typing.Tuple[bool, BitsetIter, int]: ...
    @staticmethod
    def init_last(set: Bitset) -> typing.Tuple[bool, BitsetIter, int]: ...
    def is_valid(self) -> bool: ...
    def next(self) -> typing.Tuple[bool, int]: ...
    def previous(self) -> typing.Tuple[bool, int]: ...

# override
class BookmarkList(GObject.Object, Gio.ListModel[typing.Any]):
    """
    :Constructors:

    ::

        BookmarkList(**properties)
        new(filename:str=None, attributes:str=None) -> Gtk.BookmarkList

    Object GtkBookmarkList

    Properties from GtkBookmarkList:
      filename -> gchararray: filename
      attributes -> gchararray: attributes
      io-priority -> gint: io-priority
      item-type -> GType: item-type
      loading -> gboolean: loading
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        attributes: typing.Optional[str]
        filename: str
        io_priority: int
        item_type: typing.Type[typing.Any]
        loading: bool
        n_items: int

    props: Props = ...
    def __init__(
        self,
        attributes: typing.Optional[str] = ...,
        filename: str = ...,
        io_priority: int = ...,
    ) -> None: ...
    def get_attributes(self) -> typing.Optional[str]: ...
    def get_filename(self) -> str: ...
    def get_io_priority(self) -> int: ...
    def is_loading(self) -> bool: ...
    @classmethod
    def new(
        cls,
        filename: typing.Optional[str] = None,
        attributes: typing.Optional[str] = None,
    ) -> BookmarkList: ...
    def set_attributes(self, attributes: typing.Optional[str] = None) -> None: ...
    def set_io_priority(self, io_priority: int) -> None: ...

class BookmarkListClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BookmarkListClass()
    """

    parent_class: GObject.ObjectClass = ...

class BoolFilter(Filter):
    """
    :Constructors:

    ::

        BoolFilter(**properties)
        new(expression:Gtk.Expression=None) -> Gtk.BoolFilter

    Object GtkBoolFilter

    Properties from GtkBoolFilter:
      expression -> GtkExpression: expression
      invert -> gboolean: invert

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Filter.Props):
        expression: typing.Optional[Expression]
        invert: bool

    props: Props = ...
    def __init__(
        self, expression: typing.Optional[Expression] = ..., invert: bool = ...
    ) -> None: ...
    def get_expression(self) -> typing.Optional[Expression]: ...
    def get_invert(self) -> bool: ...
    @classmethod
    def new(cls, expression: typing.Optional[Expression] = None) -> BoolFilter: ...
    def set_expression(
        self, expression: typing.Optional[Expression] = None
    ) -> None: ...
    def set_invert(self, invert: bool) -> None: ...

class BoolFilterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BoolFilterClass()
    """

    parent_class: FilterClass = ...

class Border(GObject.GBoxed):
    """
    :Constructors:

    ::

        Border()
        new() -> Gtk.Border
    """

    left: int = ...
    right: int = ...
    top: int = ...
    bottom: int = ...
    def copy(self) -> Border: ...
    def free(self) -> None: ...
    @classmethod
    def new(cls) -> Border: ...

class Box(Widget, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        Box(**properties)
        new(orientation:Gtk.Orientation, spacing:int) -> Gtk.Widget

    Object GtkBox

    Properties from GtkBox:
      spacing -> gint: spacing
      homogeneous -> gboolean: homogeneous
      baseline-child -> gint: baseline-child
      baseline-position -> GtkBaselinePosition: baseline-position

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        baseline_child: int
        baseline_position: BaselinePosition
        homogeneous: bool
        spacing: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        baseline_child: int = ...,
        baseline_position: BaselinePosition = ...,
        homogeneous: bool = ...,
        spacing: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def append(self, child: Widget) -> None: ...
    def get_baseline_child(self) -> int: ...
    def get_baseline_position(self) -> BaselinePosition: ...
    def get_homogeneous(self) -> bool: ...
    def get_spacing(self) -> int: ...
    def insert_child_after(
        self, child: Widget, sibling: typing.Optional[Widget] = None
    ) -> None: ...
    @classmethod
    def new(cls, orientation: Orientation, spacing: int) -> Box: ...
    def prepend(self, child: Widget) -> None: ...
    def remove(self, child: Widget) -> None: ...
    def reorder_child_after(
        self, child: Widget, sibling: typing.Optional[Widget] = None
    ) -> None: ...
    def set_baseline_child(self, child: int) -> None: ...
    def set_baseline_position(self, position: BaselinePosition) -> None: ...
    def set_homogeneous(self, homogeneous: bool) -> None: ...
    def set_spacing(self, spacing: int) -> None: ...

class BoxClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BoxClass()
    """

    parent_class: WidgetClass = ...
    padding: list[None] = ...

class BoxLayout(LayoutManager, Orientable):
    """
    :Constructors:

    ::

        BoxLayout(**properties)
        new(orientation:Gtk.Orientation) -> Gtk.LayoutManager

    Object GtkBoxLayout

    Properties from GtkBoxLayout:
      homogeneous -> gboolean: homogeneous
      spacing -> gint: spacing
      baseline-child -> gint: baseline-child
      baseline-position -> GtkBaselinePosition: baseline-position

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutManager.Props):
        baseline_child: int
        baseline_position: BaselinePosition
        homogeneous: bool
        spacing: int
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        baseline_child: int = ...,
        baseline_position: BaselinePosition = ...,
        homogeneous: bool = ...,
        spacing: int = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_baseline_child(self) -> int: ...
    def get_baseline_position(self) -> BaselinePosition: ...
    def get_homogeneous(self) -> bool: ...
    def get_spacing(self) -> int: ...
    @classmethod
    def new(cls, orientation: Orientation) -> BoxLayout: ...
    def set_baseline_child(self, child: int) -> None: ...
    def set_baseline_position(self, position: BaselinePosition) -> None: ...
    def set_homogeneous(self, homogeneous: bool) -> None: ...
    def set_spacing(self, spacing: int) -> None: ...

class BoxLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BoxLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class Buildable(GObject.GInterface):
    """
    Interface GtkBuildable

    Signals from GObject:
      notify (GParam)
    """
    def get_buildable_id(self) -> typing.Optional[str]: ...

class BuildableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        BuildableIface()
    """

    g_iface: GObject.TypeInterface = ...
    set_id: typing.Callable[[Buildable, str], None] = ...
    get_id: typing.Callable[[Buildable], str] = ...
    add_child: typing.Callable[
        [Buildable, Builder, GObject.Object, typing.Optional[str]], None
    ] = ...
    set_buildable_property: typing.Callable[
        [Buildable, Builder, str, typing.Any], None
    ] = ...
    construct_child: None = ...
    custom_tag_start: typing.Callable[
        [Buildable, Builder, typing.Optional[GObject.Object], str],
        typing.Tuple[bool, BuildableParser, None],
    ] = ...
    custom_tag_end: typing.Callable[
        [Buildable, Builder, typing.Optional[GObject.Object], str, None], None
    ] = ...
    custom_finished: typing.Callable[
        [Buildable, Builder, typing.Optional[GObject.Object], str, None], None
    ] = ...
    parser_finished: typing.Callable[[Buildable, Builder], None] = ...
    get_internal_child: typing.Callable[[Buildable, Builder, str], GObject.Object] = ...

class BuildableParseContext(GObject.GPointer):
    def get_element(self) -> typing.Optional[str]: ...
    def get_element_stack(self) -> list[str]: ...
    def get_position(self) -> typing.Tuple[int, int]: ...
    def pop(self) -> None: ...
    def push(self, parser: BuildableParser, user_data: None) -> None: ...

class BuildableParser(GObject.GPointer):
    """
    :Constructors:

    ::

        BuildableParser()
    """

    start_element: typing.Callable[..., None] = ...
    end_element: typing.Callable[..., None] = ...
    text: typing.Callable[..., None] = ...
    error: typing.Callable[..., None] = ...
    padding: list[None] = ...

class Builder(GObject.Object):
    """
    :Constructors:

    ::

        Builder(**properties)
        new() -> Gtk.Builder
        new_from_file(filename:str) -> Gtk.Builder
        new_from_resource(resource_path:str) -> Gtk.Builder
        new_from_string(string:str, length:int) -> Gtk.Builder

    Object GtkBuilder

    Properties from GtkBuilder:
      current-object -> GObject: current-object
      scope -> GtkBuilderScope: scope
      translation-domain -> gchararray: translation-domain

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        current_object: typing.Optional[GObject.Object]
        scope: BuilderScope
        translation_domain: typing.Optional[str]

    props: Props = ...
    g_type_instance: GObject.TypeInstance = ...
    ref_count: int = ...
    qdata: GLib.Data = ...
    def __init__(
        self,
        current_object: typing.Optional[GObject.Object] = ...,
        scope: typing.Optional[BuilderScope] = ...,
        translation_domain: typing.Optional[str] = ...,
    ) -> None: ...
    def add_from_file(self, filename: str) -> bool: ...
    def add_from_resource(self, resource_path: str) -> bool: ...
    # override
    def add_from_string(self, buffer: str, length: int = ...) -> bool: ...
    def add_objects_from_file(
        self, filename: str, object_ids: typing.Sequence[str]
    ) -> bool: ...
    def add_objects_from_resource(
        self, resource_path: str, object_ids: typing.Sequence[str]
    ) -> bool: ...
    # override
    def add_objects_from_string(self, buffer: str, object_ids: list[str]) -> int: ...
    def create_closure(
        self,
        function_name: str,
        flags: BuilderClosureFlags,
        object: typing.Optional[GObject.Object] = None,
    ) -> typing.Optional[typing.Callable[..., typing.Any]]: ...
    def define_builder_scope(): ...  # FIXME: Override is missing typing annotation
    def expose_object(self, name: str, object: GObject.Object) -> None: ...
    def extend_with_template(
        self,
        object: GObject.Object,
        template_type: typing.Type[typing.Any],
        buffer: str,
        length: int,
    ) -> bool: ...
    def get_current_object(self) -> typing.Optional[GObject.Object]: ...
    def get_object(self, name: str) -> typing.Optional[GObject.Object]: ...
    def get_objects(self) -> list[GObject.Object]: ...
    def get_scope(self) -> BuilderScope: ...
    def get_translation_domain(self) -> typing.Optional[str]: ...
    def get_type_from_name(self, type_name: str) -> typing.Type[typing.Any]: ...
    @classmethod
    def new(cls) -> Builder: ...
    @classmethod
    def new_from_file(cls, filename: str) -> Builder: ...
    @classmethod
    def new_from_resource(cls, resource_path: str) -> Builder: ...
    @classmethod
    def new_from_string(cls, string: str, length: int) -> Builder: ...
    def set_current_object(
        self, current_object: typing.Optional[GObject.Object] = None
    ) -> None: ...
    def set_scope(self, scope: typing.Optional[BuilderScope] = None) -> None: ...
    def set_translation_domain(self, domain: typing.Optional[str] = None) -> None: ...
    def value_from_string(
        self, pspec: GObject.ParamSpec, string: str
    ) -> typing.Tuple[bool, typing.Any]: ...
    def value_from_string_type(
        self, type: typing.Type[typing.Any], string: str
    ) -> typing.Tuple[bool, typing.Any]: ...

    class BuilderScope:
        """
        Object gi+_gtktemplate+BuilderScope

        Signals from GObject:
          notify (GParam)
        """

        g_type_instance: GObject.TypeInstance = ...
        ref_count: int = ...
        qdata: GLib.Data = ...
        def bind_property(
            self, *args, **kwargs
        ): ...  # FIXME: Override is missing typing annotation
        def bind_property_full(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def compat_control(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def do_create_closure(
            self, builder, func_name, flags, obj
        ): ...  # FIXME: Override is missing typing annotation
        def force_floating(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def freeze_notify(self):
            """
            Freezes the object's property-changed notification queue.

            :returns:
                A context manager which optionally can be used to
                automatically thaw notifications.

            This will freeze the object so that "notify" signals are blocked until
            the thaw_notify() method is called.

            .. code-block:: python

                with obj.freeze_notify():
                    pass
            """  # FIXME: Override is missing typing annotation
        def get_data(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def get_property(
            self, *args, **kwargs
        ): ...  # FIXME: Override is missing typing annotation
        def get_qdata(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def getv(
            self, names: typing.Sequence[str], values: typing.Sequence[typing.Any]
        ) -> None: ...
        def interface_find_property(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def interface_install_property(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def interface_list_properties(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def is_floating(self) -> bool: ...
        @classmethod
        def newv(
            cls,
            object_type: typing.Type[typing.Any],
            parameters: typing.Sequence[GObject.Parameter],
        ) -> Object: ...
        def notify(self, property_name: str) -> None: ...
        def notify_by_pspec(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def ref(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def ref_sink(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def run_dispose(self) -> None: ...
        def set_data(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def set_property(
            self, *args, **kwargs
        ): ...  # FIXME: Override is missing typing annotation
        def steal_data(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def steal_qdata(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def thaw_notify(self) -> None: ...
        def unref(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation
        def watch_closure(
            self, *args, **kargs
        ): ...  # FIXME: Override is missing typing annotation

class BuilderCScope(GObject.Object, BuilderScope):
    """
    :Constructors:

    ::

        BuilderCScope(**properties)
        new() -> Gtk.BuilderCScope

    Object GtkBuilderCScope

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    def add_callback_symbol(
        self, callback_name: str, callback_symbol: typing.Callable[[], None]
    ) -> None: ...
    @classmethod
    def new(cls) -> BuilderCScope: ...

class BuilderCScopeClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BuilderCScopeClass()
    """

    parent_class: GObject.ObjectClass = ...

class BuilderClass(GObject.GPointer): ...

class BuilderListItemFactory(ListItemFactory):
    """
    :Constructors:

    ::

        BuilderListItemFactory(**properties)
        new_from_bytes(scope:Gtk.BuilderScope=None, bytes:GLib.Bytes) -> Gtk.ListItemFactory
        new_from_resource(scope:Gtk.BuilderScope=None, resource_path:str) -> Gtk.ListItemFactory

    Object GtkBuilderListItemFactory

    Properties from GtkBuilderListItemFactory:
      bytes -> GBytes: bytes
      resource -> gchararray: resource
      scope -> GtkBuilderScope: scope

    Signals from GObject:
      notify (GParam)
    """
    class Props(ListItemFactory.Props):
        bytes: GLib.Bytes
        resource: typing.Optional[str]
        scope: typing.Optional[BuilderScope]

    props: Props = ...
    def __init__(
        self, bytes: GLib.Bytes = ..., resource: str = ..., scope: BuilderScope = ...
    ) -> None: ...
    def get_bytes(self) -> GLib.Bytes: ...
    def get_resource(self) -> typing.Optional[str]: ...
    def get_scope(self) -> typing.Optional[BuilderScope]: ...
    @classmethod
    def new_from_bytes(
        cls, scope: typing.Optional[BuilderScope], bytes: GLib.Bytes
    ) -> BuilderListItemFactory: ...
    @classmethod
    def new_from_resource(
        cls, scope: typing.Optional[BuilderScope], resource_path: str
    ) -> BuilderListItemFactory: ...

class BuilderListItemFactoryClass(GObject.GPointer): ...
class BuilderScope(GObject.GInterface): ...

class BuilderScopeInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        BuilderScopeInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_type_from_name: typing.Callable[
        [BuilderScope, Builder, str], typing.Type[typing.Any]
    ] = ...
    get_type_from_function: typing.Callable[
        [BuilderScope, Builder, str], typing.Type[typing.Any]
    ] = ...
    create_closure: typing.Callable[
        [BuilderScope, Builder, str, BuilderClosureFlags, GObject.Object],
        typing.Callable[..., typing.Any],
    ] = ...

class Button(Widget, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Button(**properties)
        new() -> Gtk.Widget
        new_from_icon_name(icon_name:str) -> Gtk.Widget
        new_with_label(label:str) -> Gtk.Widget
        new_with_mnemonic(label:str) -> Gtk.Widget

    Object GtkButton

    Signals from GtkButton:
      activate ()
      clicked ()

    Properties from GtkButton:
      label -> gchararray: label
      has-frame -> gboolean: has-frame
      use-underline -> gboolean: use-underline
      icon-name -> gchararray: icon-name
      child -> GtkWidget: child
      can-shrink -> gboolean: can-shrink

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        can_shrink: bool
        child: typing.Optional[Widget]
        has_frame: bool
        icon_name: typing.Optional[str]
        label: typing.Optional[str]
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        can_shrink: bool = ...,
        child: typing.Optional[Widget] = ...,
        has_frame: bool = ...,
        icon_name: str = ...,
        label: str = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def do_activate(self) -> None: ...
    def do_clicked(self) -> None: ...
    def get_can_shrink(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_has_frame(self) -> bool: ...
    def get_icon_name(self) -> typing.Optional[str]: ...
    def get_label(self) -> typing.Optional[str]: ...
    def get_use_underline(self) -> bool: ...
    @classmethod
    def new(cls) -> Button: ...
    @classmethod
    def new_from_icon_name(cls, icon_name: str) -> Button: ...
    @classmethod
    def new_with_label(cls, label: str) -> Button: ...
    @classmethod
    def new_with_mnemonic(cls, label: str) -> Button: ...
    def set_can_shrink(self, can_shrink: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_has_frame(self, has_frame: bool) -> None: ...
    def set_icon_name(self, icon_name: str) -> None: ...
    def set_label(self, label: str) -> None: ...
    def set_use_underline(self, use_underline: bool) -> None: ...

class ButtonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ButtonClass()
    """

    parent_class: WidgetClass = ...
    clicked: typing.Callable[[Button], None] = ...
    activate: typing.Callable[[Button], None] = ...
    padding: list[None] = ...

class ButtonPrivate(GObject.GPointer): ...

class CClosureExpression(Expression):
    """
    :Constructors:

    ::

        CClosureExpression(**properties)
        new(value_type:GType, marshal:GObject.ClosureMarshal=None, params:list, callback_func:GObject.Callback, user_data=None) -> Gtk.CClosureExpression
    """
    @classmethod
    def new(
        cls,
        value_type: typing.Type[typing.Any],
        marshal: typing.Optional[
            typing.Callable[
                [
                    typing.Callable[..., typing.Any],
                    typing.Optional[typing.Any],
                    typing.Sequence[typing.Any],
                    None,
                    None,
                ],
                None,
            ]
        ],
        params: typing.Sequence[Expression],
        callback_func: typing.Callable[..., None],
        *user_data: typing.Any,
    ) -> CClosureExpression: ...

class Calendar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Calendar(**properties)
        new() -> Gtk.Widget

    Object GtkCalendar

    Signals from GtkCalendar:
      day-selected ()
      prev-month ()
      next-month ()
      prev-year ()
      next-year ()

    Properties from GtkCalendar:
      date -> GDateTime: date
      year -> gint: year
      month -> gint: month
      day -> gint: day
      show-heading -> gboolean: show-heading
      show-day-names -> gboolean: show-day-names
      show-week-numbers -> gboolean: show-week-numbers

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        date: GLib.DateTime
        day: int
        month: int
        show_day_names: bool
        show_heading: bool
        show_week_numbers: bool
        year: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        date: GLib.DateTime = ...,
        day: int = ...,
        month: int = ...,
        show_day_names: bool = ...,
        show_heading: bool = ...,
        show_week_numbers: bool = ...,
        year: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def clear_marks(self) -> None: ...
    def get_date(self) -> GLib.DateTime: ...
    def get_day(self) -> int: ...
    def get_day_is_marked(self, day: int) -> bool: ...
    def get_month(self) -> int: ...
    def get_show_day_names(self) -> bool: ...
    def get_show_heading(self) -> bool: ...
    def get_show_week_numbers(self) -> bool: ...
    def get_year(self) -> int: ...
    def mark_day(self, day: int) -> None: ...
    @classmethod
    def new(cls) -> Calendar: ...
    def select_day(self, date: GLib.DateTime) -> None: ...
    def set_date(self, date: GLib.DateTime) -> None: ...
    def set_day(self, day: int) -> None: ...
    def set_month(self, month: int) -> None: ...
    def set_show_day_names(self, value: bool) -> None: ...
    def set_show_heading(self, value: bool) -> None: ...
    def set_show_week_numbers(self, value: bool) -> None: ...
    def set_year(self, year: int) -> None: ...
    def unmark_day(self, day: int) -> None: ...

class CallbackAction(ShortcutAction):
    """
    :Constructors:

    ::

        CallbackAction(**properties)
        new(callback:Gtk.ShortcutFunc, data=None) -> Gtk.CallbackAction

    Object GtkCallbackAction

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(
        cls, callback: typing.Callable[..., bool], *data: typing.Any
    ) -> CallbackAction: ...

class CallbackActionClass(GObject.GPointer): ...

class CellArea(GObject.InitiallyUnowned, Buildable, CellLayout):
    """
    :Constructors:

    ::

        CellArea(**properties)

    Object GtkCellArea

    Signals from GtkCellArea:
      apply-attributes (GtkTreeModel, GtkTreeIter, gboolean, gboolean)
      add-editable (GtkCellRenderer, GtkCellEditable, GdkRectangle, gchararray)
      remove-editable (GtkCellRenderer, GtkCellEditable)
      focus-changed (GtkCellRenderer, gchararray)

    Properties from GtkCellArea:
      focus-cell -> GtkCellRenderer: focus-cell
      edited-cell -> GtkCellRenderer: edited-cell
      edit-widget -> GtkCellEditable: edit-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.InitiallyUnowned.Props):
        edit_widget: typing.Optional[CellEditable]
        edited_cell: typing.Optional[CellRenderer]
        focus_cell: typing.Optional[CellRenderer]

    props: Props = ...
    parent_instance: GObject.InitiallyUnowned = ...
    def __init__(self, focus_cell: typing.Optional[CellRenderer] = ...) -> None: ...
    def activate(
        self,
        context: CellAreaContext,
        widget: Widget,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
        edit_only: bool,
    ) -> bool: ...
    def activate_cell(
        self,
        widget: Widget,
        renderer: CellRenderer,
        event: Gdk.Event,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> bool: ...
    def add(self, renderer: CellRenderer) -> None: ...
    def add_focus_sibling(
        self, renderer: CellRenderer, sibling: CellRenderer
    ) -> None: ...
    def apply_attributes(
        self,
        tree_model: TreeModel,
        iter: TreeIter,
        is_expander: bool,
        is_expanded: bool,
    ) -> None: ...
    def attribute_connect(
        self, renderer: CellRenderer, attribute: str, column: int
    ) -> None: ...
    def attribute_disconnect(self, renderer: CellRenderer, attribute: str) -> None: ...
    def attribute_get_column(self, renderer: CellRenderer, attribute: str) -> int: ...
    def cell_get_property(
        self, renderer: CellRenderer, property_name: str, value: typing.Any
    ) -> None: ...
    def cell_set_property(
        self, renderer: CellRenderer, property_name: str, value: typing.Any
    ) -> None: ...
    def copy_context(self, context: CellAreaContext) -> CellAreaContext: ...
    def create_context(self) -> CellAreaContext: ...
    def do_activate(
        self,
        context: CellAreaContext,
        widget: Widget,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
        edit_only: bool,
    ) -> bool: ...
    def do_add(self, renderer: CellRenderer) -> None: ...
    def do_apply_attributes(
        self,
        tree_model: TreeModel,
        iter: TreeIter,
        is_expander: bool,
        is_expanded: bool,
    ) -> None: ...
    def do_copy_context(self, context: CellAreaContext) -> CellAreaContext: ...
    def do_create_context(self) -> CellAreaContext: ...
    def do_event(
        self,
        context: CellAreaContext,
        widget: Widget,
        event: Gdk.Event,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> int: ...
    def do_focus(self, direction: DirectionType) -> bool: ...
    def do_foreach(
        self, callback: typing.Callable[..., bool], *callback_data: typing.Any
    ) -> None: ...
    def do_foreach_alloc(
        self,
        context: CellAreaContext,
        widget: Widget,
        cell_area: Gdk.Rectangle,
        background_area: Gdk.Rectangle,
        callback: typing.Callable[..., bool],
        *callback_data: typing.Any,
    ) -> None: ...
    def do_get_cell_property(
        self,
        renderer: CellRenderer,
        property_id: int,
        value: typing.Any,
        pspec: GObject.ParamSpec,
    ) -> None: ...
    def do_get_preferred_height(
        self, context: CellAreaContext, widget: Widget
    ) -> typing.Tuple[int, int]: ...
    def do_get_preferred_height_for_width(
        self, context: CellAreaContext, widget: Widget, width: int
    ) -> typing.Tuple[int, int]: ...
    def do_get_preferred_width(
        self, context: CellAreaContext, widget: Widget
    ) -> typing.Tuple[int, int]: ...
    def do_get_preferred_width_for_height(
        self, context: CellAreaContext, widget: Widget, height: int
    ) -> typing.Tuple[int, int]: ...
    def do_get_request_mode(self) -> SizeRequestMode: ...
    def do_is_activatable(self) -> bool: ...
    def do_remove(self, renderer: CellRenderer) -> None: ...
    def do_set_cell_property(
        self,
        renderer: CellRenderer,
        property_id: int,
        value: typing.Any,
        pspec: GObject.ParamSpec,
    ) -> None: ...
    def do_snapshot(
        self,
        context: CellAreaContext,
        widget: Widget,
        snapshot: Snapshot,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
        paint_focus: bool,
    ) -> None: ...
    def event(
        self,
        context: CellAreaContext,
        widget: Widget,
        event: Gdk.Event,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> int: ...
    # override
    def find_cell_property(self, property_name: str) -> GObject.ParamSpec: ...
    def focus(self, direction: DirectionType) -> bool: ...
    def foreach(
        self, callback: typing.Callable[..., bool], *callback_data: typing.Any
    ) -> None: ...
    def foreach_alloc(
        self,
        context: CellAreaContext,
        widget: Widget,
        cell_area: Gdk.Rectangle,
        background_area: Gdk.Rectangle,
        callback: typing.Callable[..., bool],
        *callback_data: typing.Any,
    ) -> None: ...
    def get_cell_allocation(
        self,
        context: CellAreaContext,
        widget: Widget,
        renderer: CellRenderer,
        cell_area: Gdk.Rectangle,
    ) -> Gdk.Rectangle: ...
    def get_cell_at_position(
        self,
        context: CellAreaContext,
        widget: Widget,
        cell_area: Gdk.Rectangle,
        x: int,
        y: int,
    ) -> typing.Tuple[CellRenderer, Gdk.Rectangle]: ...
    def get_current_path_string(self) -> str: ...
    def get_edit_widget(self) -> typing.Optional[CellEditable]: ...
    def get_edited_cell(self) -> typing.Optional[CellRenderer]: ...
    def get_focus_cell(self) -> typing.Optional[CellRenderer]: ...
    def get_focus_from_sibling(
        self, renderer: CellRenderer
    ) -> typing.Optional[CellRenderer]: ...
    def get_focus_siblings(self, renderer: CellRenderer) -> list[CellRenderer]: ...
    def get_preferred_height(
        self, context: CellAreaContext, widget: Widget
    ) -> typing.Tuple[int, int]: ...
    def get_preferred_height_for_width(
        self, context: CellAreaContext, widget: Widget, width: int
    ) -> typing.Tuple[int, int]: ...
    def get_preferred_width(
        self, context: CellAreaContext, widget: Widget
    ) -> typing.Tuple[int, int]: ...
    def get_preferred_width_for_height(
        self, context: CellAreaContext, widget: Widget, height: int
    ) -> typing.Tuple[int, int]: ...
    def get_request_mode(self) -> SizeRequestMode: ...
    def has_renderer(self, renderer: CellRenderer) -> bool: ...
    def inner_cell_area(
        self, widget: Widget, cell_area: Gdk.Rectangle
    ) -> Gdk.Rectangle: ...
    # override
    def install_cell_property(
        self, property_id: int, pspec: GObject.ParamSpec
    ) -> None: ...
    def is_activatable(self) -> bool: ...
    def is_focus_sibling(
        self, renderer: CellRenderer, sibling: CellRenderer
    ) -> bool: ...
    # override
    def list_cell_properties(self) -> list[GObject.ParamSpec]: ...
    def remove(self, renderer: CellRenderer) -> None: ...
    def remove_focus_sibling(
        self, renderer: CellRenderer, sibling: CellRenderer
    ) -> None: ...
    def request_renderer(
        self,
        renderer: CellRenderer,
        orientation: Orientation,
        widget: Widget,
        for_size: int,
    ) -> typing.Tuple[int, int]: ...
    def set_focus_cell(
        self, renderer: typing.Optional[CellRenderer] = None
    ) -> None: ...
    def snapshot(
        self,
        context: CellAreaContext,
        widget: Widget,
        snapshot: Snapshot,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
        paint_focus: bool,
    ) -> None: ...
    def stop_editing(self, canceled: bool) -> None: ...

class CellAreaBox(CellArea, Buildable, CellLayout, Orientable):
    """
    :Constructors:

    ::

        CellAreaBox(**properties)
        new() -> Gtk.CellArea

    Object GtkCellAreaBox

    Properties from GtkCellAreaBox:
      spacing -> gint: spacing

    Signals from GtkCellArea:
      apply-attributes (GtkTreeModel, GtkTreeIter, gboolean, gboolean)
      add-editable (GtkCellRenderer, GtkCellEditable, GdkRectangle, gchararray)
      remove-editable (GtkCellRenderer, GtkCellEditable)
      focus-changed (GtkCellRenderer, gchararray)

    Properties from GtkCellArea:
      focus-cell -> GtkCellRenderer: focus-cell
      edited-cell -> GtkCellRenderer: edited-cell
      edit-widget -> GtkCellEditable: edit-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellArea.Props):
        spacing: int
        edit_widget: typing.Optional[CellEditable]
        edited_cell: typing.Optional[CellRenderer]
        focus_cell: typing.Optional[CellRenderer]
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        spacing: int = ...,
        focus_cell: typing.Optional[CellRenderer] = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_spacing(self) -> int: ...
    @classmethod
    def new(cls) -> CellAreaBox: ...
    def pack_end(
        self, renderer: CellRenderer, expand: bool, align: bool, fixed: bool
    ) -> None: ...
    def pack_start(
        self, renderer: CellRenderer, expand: bool, align: bool, fixed: bool
    ) -> None: ...
    def set_spacing(self, spacing: int) -> None: ...

class CellAreaClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CellAreaClass()
    """

    parent_class: GObject.InitiallyUnownedClass = ...
    add: typing.Callable[[CellArea, CellRenderer], None] = ...
    remove: typing.Callable[[CellArea, CellRenderer], None] = ...
    foreach: typing.Callable[..., None] = ...
    foreach_alloc: typing.Callable[..., None] = ...
    event: typing.Callable[
        [
            CellArea,
            CellAreaContext,
            Widget,
            Gdk.Event,
            Gdk.Rectangle,
            CellRendererState,
        ],
        int,
    ] = ...
    snapshot: typing.Callable[
        [
            CellArea,
            CellAreaContext,
            Widget,
            Snapshot,
            Gdk.Rectangle,
            Gdk.Rectangle,
            CellRendererState,
            bool,
        ],
        None,
    ] = ...
    apply_attributes: typing.Callable[
        [CellArea, TreeModel, TreeIter, bool, bool], None
    ] = ...
    create_context: typing.Callable[[CellArea], CellAreaContext] = ...
    copy_context: typing.Callable[[CellArea, CellAreaContext], CellAreaContext] = ...
    get_request_mode: typing.Callable[[CellArea], SizeRequestMode] = ...
    get_preferred_width: typing.Callable[
        [CellArea, CellAreaContext, Widget], typing.Tuple[int, int]
    ] = ...
    get_preferred_height_for_width: typing.Callable[
        [CellArea, CellAreaContext, Widget, int], typing.Tuple[int, int]
    ] = ...
    get_preferred_height: typing.Callable[
        [CellArea, CellAreaContext, Widget], typing.Tuple[int, int]
    ] = ...
    get_preferred_width_for_height: typing.Callable[
        [CellArea, CellAreaContext, Widget, int], typing.Tuple[int, int]
    ] = ...
    set_cell_property: typing.Callable[
        [CellArea, CellRenderer, int, typing.Any, GObject.ParamSpec], None
    ] = ...
    get_cell_property: typing.Callable[
        [CellArea, CellRenderer, int, typing.Any, GObject.ParamSpec], None
    ] = ...
    focus: typing.Callable[[CellArea, DirectionType], bool] = ...
    is_activatable: typing.Callable[[CellArea], bool] = ...
    activate: typing.Callable[
        [CellArea, CellAreaContext, Widget, Gdk.Rectangle, CellRendererState, bool],
        bool,
    ] = ...
    padding: list[None] = ...
    def find_cell_property(self, property_name: str) -> GObject.ParamSpec: ...
    def install_cell_property(
        self, property_id: int, pspec: GObject.ParamSpec
    ) -> None: ...
    def list_cell_properties(self) -> list[GObject.ParamSpec]: ...

class CellAreaContext(GObject.Object):
    """
    :Constructors:

    ::

        CellAreaContext(**properties)

    Object GtkCellAreaContext

    Properties from GtkCellAreaContext:
      area -> GtkCellArea: area
      minimum-width -> gint: minimum-width
      natural-width -> gint: natural-width
      minimum-height -> gint: minimum-height
      natural-height -> gint: natural-height

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        area: CellArea
        minimum_height: int
        minimum_width: int
        natural_height: int
        natural_width: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(self, area: CellArea = ...) -> None: ...
    def allocate(self, width: int, height: int) -> None: ...
    def do_allocate(self, width: int, height: int) -> None: ...
    def do_get_preferred_height_for_width(
        self, width: int
    ) -> typing.Tuple[int, int]: ...
    def do_get_preferred_width_for_height(
        self, height: int
    ) -> typing.Tuple[int, int]: ...
    def do_reset(self) -> None: ...
    def get_allocation(self) -> typing.Tuple[int, int]: ...
    def get_area(self) -> CellArea: ...
    def get_preferred_height(self) -> typing.Tuple[int, int]: ...
    def get_preferred_height_for_width(self, width: int) -> typing.Tuple[int, int]: ...
    def get_preferred_width(self) -> typing.Tuple[int, int]: ...
    def get_preferred_width_for_height(self, height: int) -> typing.Tuple[int, int]: ...
    def push_preferred_height(
        self, minimum_height: int, natural_height: int
    ) -> None: ...
    def push_preferred_width(self, minimum_width: int, natural_width: int) -> None: ...
    def reset(self) -> None: ...

class CellAreaContextClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CellAreaContextClass()
    """

    parent_class: GObject.ObjectClass = ...
    allocate: typing.Callable[[CellAreaContext, int, int], None] = ...
    reset: typing.Callable[[CellAreaContext], None] = ...
    get_preferred_height_for_width: typing.Callable[
        [CellAreaContext, int], typing.Tuple[int, int]
    ] = ...
    get_preferred_width_for_height: typing.Callable[
        [CellAreaContext, int], typing.Tuple[int, int]
    ] = ...
    padding: list[None] = ...

class CellAreaContextPrivate(GObject.GPointer): ...

class CellEditable(GObject.GInterface):
    """
    Interface GtkCellEditable

    Signals from GObject:
      notify (GParam)
    """
    def editing_done(self) -> None: ...
    def remove_widget(self) -> None: ...
    def start_editing(self, event: typing.Optional[Gdk.Event] = None) -> None: ...

class CellEditableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        CellEditableIface()
    """

    g_iface: GObject.TypeInterface = ...
    editing_done: typing.Callable[[CellEditable], None] = ...
    remove_widget: typing.Callable[[CellEditable], None] = ...
    start_editing: typing.Callable[
        [CellEditable, typing.Optional[Gdk.Event]], None
    ] = ...

class CellLayout(GObject.GInterface):
    """
    Interface GtkCellLayout

    Signals from GObject:
      notify (GParam)
    """
    def add_attribute(
        self, cell: CellRenderer, attribute: str, column: int
    ) -> None: ...
    def clear(self) -> None: ...
    def clear_attributes(self, cell: CellRenderer) -> None: ...
    def get_area(self) -> typing.Optional[CellArea]: ...
    def get_cells(self) -> list[CellRenderer]: ...
    def pack_end(self, cell: CellRenderer, expand: bool) -> None: ...
    def pack_start(self, cell: CellRenderer, expand: bool) -> None: ...
    def reorder(self, cell: CellRenderer, position: int) -> None: ...
    def set_cell_data_func(
        self,
        cell: CellRenderer,
        func: typing.Optional[typing.Callable[..., None]] = None,
        *func_data: typing.Any,
    ) -> None: ...

class CellLayoutIface(GObject.GPointer):
    """
    :Constructors:

    ::

        CellLayoutIface()
    """

    g_iface: GObject.TypeInterface = ...
    pack_start: typing.Callable[[CellLayout, CellRenderer, bool], None] = ...
    pack_end: typing.Callable[[CellLayout, CellRenderer, bool], None] = ...
    clear: typing.Callable[[CellLayout], None] = ...
    add_attribute: typing.Callable[[CellLayout, CellRenderer, str, int], None] = ...
    set_cell_data_func: typing.Callable[..., None] = ...
    clear_attributes: typing.Callable[[CellLayout, CellRenderer], None] = ...
    reorder: typing.Callable[[CellLayout, CellRenderer, int], None] = ...
    get_cells: typing.Callable[[CellLayout], list[CellRenderer]] = ...
    get_area: typing.Callable[[CellLayout], typing.Optional[CellArea]] = ...

class CellRenderer(GObject.InitiallyUnowned):
    """
    :Constructors:

    ::

        CellRenderer(**properties)

    Object GtkCellRenderer

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.InitiallyUnowned.Props):
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        cell_background: str

    props: Props = ...
    parent_instance: GObject.InitiallyUnowned = ...
    priv: CellRendererPrivate = ...
    def __init__(
        self,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    def activate(
        self,
        event: Gdk.Event,
        widget: Widget,
        path: str,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> bool: ...
    def do_activate(
        self,
        event: Gdk.Event,
        widget: Widget,
        path: str,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> bool: ...
    def do_editing_canceled(self) -> None: ...
    def do_editing_started(self, editable: CellEditable, path: str) -> None: ...
    def do_get_aligned_area(
        self, widget: Widget, flags: CellRendererState, cell_area: Gdk.Rectangle
    ) -> Gdk.Rectangle: ...
    def do_get_preferred_height(self, widget: Widget) -> typing.Tuple[int, int]: ...
    def do_get_preferred_height_for_width(
        self, widget: Widget, width: int
    ) -> typing.Tuple[int, int]: ...
    def do_get_preferred_width(self, widget: Widget) -> typing.Tuple[int, int]: ...
    def do_get_preferred_width_for_height(
        self, widget: Widget, height: int
    ) -> typing.Tuple[int, int]: ...
    def do_get_request_mode(self) -> SizeRequestMode: ...
    def do_snapshot(
        self,
        snapshot: Snapshot,
        widget: Widget,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> None: ...
    def do_start_editing(
        self,
        event: typing.Optional[Gdk.Event],
        widget: Widget,
        path: str,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> typing.Optional[CellEditable]: ...
    def get_aligned_area(
        self, widget: Widget, flags: CellRendererState, cell_area: Gdk.Rectangle
    ) -> Gdk.Rectangle: ...
    def get_alignment(self) -> typing.Tuple[float, float]: ...
    def get_fixed_size(self) -> typing.Tuple[int, int]: ...
    def get_is_expanded(self) -> bool: ...
    def get_is_expander(self) -> bool: ...
    def get_padding(self) -> typing.Tuple[int, int]: ...
    def get_preferred_height(self, widget: Widget) -> typing.Tuple[int, int]: ...
    def get_preferred_height_for_width(
        self, widget: Widget, width: int
    ) -> typing.Tuple[int, int]: ...
    def get_preferred_size(
        self, widget: Widget
    ) -> typing.Tuple[Requisition, Requisition]: ...
    def get_preferred_width(self, widget: Widget) -> typing.Tuple[int, int]: ...
    def get_preferred_width_for_height(
        self, widget: Widget, height: int
    ) -> typing.Tuple[int, int]: ...
    def get_request_mode(self) -> SizeRequestMode: ...
    def get_sensitive(self) -> bool: ...
    def get_state(
        self, widget: typing.Optional[Widget], cell_state: CellRendererState
    ) -> StateFlags: ...
    def get_visible(self) -> bool: ...
    def is_activatable(self) -> bool: ...
    def set_alignment(self, xalign: float, yalign: float) -> None: ...
    def set_fixed_size(self, width: int, height: int) -> None: ...
    def set_is_expanded(self, is_expanded: bool) -> None: ...
    def set_is_expander(self, is_expander: bool) -> None: ...
    def set_padding(self, xpad: int, ypad: int) -> None: ...
    def set_sensitive(self, sensitive: bool) -> None: ...
    def set_visible(self, visible: bool) -> None: ...
    def snapshot(
        self,
        snapshot: Snapshot,
        widget: Widget,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> None: ...
    def start_editing(
        self,
        event: typing.Optional[Gdk.Event],
        widget: Widget,
        path: str,
        background_area: Gdk.Rectangle,
        cell_area: Gdk.Rectangle,
        flags: CellRendererState,
    ) -> typing.Optional[CellEditable]: ...
    def stop_editing(self, canceled: bool) -> None: ...

class CellRendererAccel(CellRendererText):
    """
    :Constructors:

    ::

        CellRendererAccel(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererAccel

    Signals from GtkCellRendererAccel:
      accel-edited (gchararray, guint, GdkModifierType, guint)
      accel-cleared (gchararray)

    Properties from GtkCellRendererAccel:
      accel-key -> guint: accel-key
      accel-mods -> GdkModifierType: accel-mods
      keycode -> guint: keycode
      accel-mode -> GtkCellRendererAccelMode: accel-mode

    Signals from GtkCellRendererText:
      edited (gchararray, gchararray)

    Properties from GtkCellRendererText:
      text -> gchararray: text
      markup -> gchararray: markup
      attributes -> PangoAttrList: attributes
      single-paragraph-mode -> gboolean: single-paragraph-mode
      width-chars -> gint: width-chars
      max-width-chars -> gint: max-width-chars
      wrap-width -> gint: wrap-width
      alignment -> PangoAlignment: alignment
      placeholder-text -> gchararray: placeholder-text
      background -> gchararray: background
      foreground -> gchararray: foreground
      background-rgba -> GdkRGBA: background-rgba
      foreground-rgba -> GdkRGBA: foreground-rgba
      font -> gchararray: font
      font-desc -> PangoFontDescription: font-desc
      family -> gchararray: family
      style -> PangoStyle: style
      variant -> PangoVariant: variant
      weight -> gint: weight
      stretch -> PangoStretch: stretch
      size -> gint: size
      size-points -> gdouble: size-points
      scale -> gdouble: scale
      editable -> gboolean: editable
      strikethrough -> gboolean: strikethrough
      underline -> PangoUnderline: underline
      rise -> gint: rise
      language -> gchararray: language
      ellipsize -> PangoEllipsizeMode: ellipsize
      wrap-mode -> PangoWrapMode: wrap-mode
      background-set -> gboolean: background-set
      foreground-set -> gboolean: foreground-set
      family-set -> gboolean: family-set
      style-set -> gboolean: style-set
      variant-set -> gboolean: variant-set
      weight-set -> gboolean: weight-set
      stretch-set -> gboolean: stretch-set
      size-set -> gboolean: size-set
      scale-set -> gboolean: scale-set
      editable-set -> gboolean: editable-set
      strikethrough-set -> gboolean: strikethrough-set
      underline-set -> gboolean: underline-set
      rise-set -> gboolean: rise-set
      language-set -> gboolean: language-set
      ellipsize-set -> gboolean: ellipsize-set
      align-set -> gboolean: align-set

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRendererText.Props):
        accel_key: int
        accel_mode: CellRendererAccelMode
        accel_mods: Gdk.ModifierType
        keycode: int
        align_set: bool
        alignment: Pango.Alignment
        attributes: Pango.AttrList
        background_rgba: Gdk.RGBA
        background_set: bool
        editable: bool
        editable_set: bool
        ellipsize: Pango.EllipsizeMode
        ellipsize_set: bool
        family: str
        family_set: bool
        font: str
        font_desc: Pango.FontDescription
        foreground_rgba: Gdk.RGBA
        foreground_set: bool
        language: str
        language_set: bool
        max_width_chars: int
        placeholder_text: str
        rise: int
        rise_set: bool
        scale: float
        scale_set: bool
        single_paragraph_mode: bool
        size: int
        size_points: float
        size_set: bool
        stretch: Pango.Stretch
        stretch_set: bool
        strikethrough: bool
        strikethrough_set: bool
        style: Pango.Style
        style_set: bool
        text: str
        underline: Pango.Underline
        underline_set: bool
        variant: Pango.Variant
        variant_set: bool
        weight: int
        weight_set: bool
        width_chars: int
        wrap_mode: Pango.WrapMode
        wrap_width: int
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        background: str
        foreground: str
        markup: str
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        accel_key: int = ...,
        accel_mode: CellRendererAccelMode = ...,
        accel_mods: Gdk.ModifierType = ...,
        keycode: int = ...,
        align_set: bool = ...,
        alignment: Pango.Alignment = ...,
        attributes: Pango.AttrList = ...,
        background: str = ...,
        background_rgba: Gdk.RGBA = ...,
        background_set: bool = ...,
        editable: bool = ...,
        editable_set: bool = ...,
        ellipsize: Pango.EllipsizeMode = ...,
        ellipsize_set: bool = ...,
        family: str = ...,
        family_set: bool = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        foreground: str = ...,
        foreground_rgba: Gdk.RGBA = ...,
        foreground_set: bool = ...,
        language: str = ...,
        language_set: bool = ...,
        markup: str = ...,
        max_width_chars: int = ...,
        placeholder_text: str = ...,
        rise: int = ...,
        rise_set: bool = ...,
        scale: float = ...,
        scale_set: bool = ...,
        single_paragraph_mode: bool = ...,
        size: int = ...,
        size_points: float = ...,
        size_set: bool = ...,
        stretch: Pango.Stretch = ...,
        stretch_set: bool = ...,
        strikethrough: bool = ...,
        strikethrough_set: bool = ...,
        style: Pango.Style = ...,
        style_set: bool = ...,
        text: str = ...,
        underline: Pango.Underline = ...,
        underline_set: bool = ...,
        variant: Pango.Variant = ...,
        variant_set: bool = ...,
        weight: int = ...,
        weight_set: bool = ...,
        width_chars: int = ...,
        wrap_mode: Pango.WrapMode = ...,
        wrap_width: int = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> CellRendererAccel: ...

class CellRendererClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CellRendererClass()
    """

    parent_class: GObject.InitiallyUnownedClass = ...
    get_request_mode: typing.Callable[[CellRenderer], SizeRequestMode] = ...
    get_preferred_width: typing.Callable[
        [CellRenderer, Widget], typing.Tuple[int, int]
    ] = ...
    get_preferred_height_for_width: typing.Callable[
        [CellRenderer, Widget, int], typing.Tuple[int, int]
    ] = ...
    get_preferred_height: typing.Callable[
        [CellRenderer, Widget], typing.Tuple[int, int]
    ] = ...
    get_preferred_width_for_height: typing.Callable[
        [CellRenderer, Widget, int], typing.Tuple[int, int]
    ] = ...
    get_aligned_area: typing.Callable[
        [CellRenderer, Widget, CellRendererState, Gdk.Rectangle], Gdk.Rectangle
    ] = ...
    snapshot: typing.Callable[
        [
            CellRenderer,
            Snapshot,
            Widget,
            Gdk.Rectangle,
            Gdk.Rectangle,
            CellRendererState,
        ],
        None,
    ] = ...
    activate: typing.Callable[
        [
            CellRenderer,
            Gdk.Event,
            Widget,
            str,
            Gdk.Rectangle,
            Gdk.Rectangle,
            CellRendererState,
        ],
        bool,
    ] = ...
    start_editing: typing.Callable[
        [
            CellRenderer,
            typing.Optional[Gdk.Event],
            Widget,
            str,
            Gdk.Rectangle,
            Gdk.Rectangle,
            CellRendererState,
        ],
        typing.Optional[CellEditable],
    ] = ...
    editing_canceled: typing.Callable[[CellRenderer], None] = ...
    editing_started: typing.Callable[[CellRenderer, CellEditable, str], None] = ...
    padding: list[None] = ...

class CellRendererClassPrivate(GObject.GPointer): ...

class CellRendererCombo(CellRendererText):
    """
    :Constructors:

    ::

        CellRendererCombo(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererCombo

    Signals from GtkCellRendererCombo:
      changed (gchararray, GtkTreeIter)

    Properties from GtkCellRendererCombo:
      model -> GtkTreeModel: model
      text-column -> gint: text-column
      has-entry -> gboolean: has-entry

    Signals from GtkCellRendererText:
      edited (gchararray, gchararray)

    Properties from GtkCellRendererText:
      text -> gchararray: text
      markup -> gchararray: markup
      attributes -> PangoAttrList: attributes
      single-paragraph-mode -> gboolean: single-paragraph-mode
      width-chars -> gint: width-chars
      max-width-chars -> gint: max-width-chars
      wrap-width -> gint: wrap-width
      alignment -> PangoAlignment: alignment
      placeholder-text -> gchararray: placeholder-text
      background -> gchararray: background
      foreground -> gchararray: foreground
      background-rgba -> GdkRGBA: background-rgba
      foreground-rgba -> GdkRGBA: foreground-rgba
      font -> gchararray: font
      font-desc -> PangoFontDescription: font-desc
      family -> gchararray: family
      style -> PangoStyle: style
      variant -> PangoVariant: variant
      weight -> gint: weight
      stretch -> PangoStretch: stretch
      size -> gint: size
      size-points -> gdouble: size-points
      scale -> gdouble: scale
      editable -> gboolean: editable
      strikethrough -> gboolean: strikethrough
      underline -> PangoUnderline: underline
      rise -> gint: rise
      language -> gchararray: language
      ellipsize -> PangoEllipsizeMode: ellipsize
      wrap-mode -> PangoWrapMode: wrap-mode
      background-set -> gboolean: background-set
      foreground-set -> gboolean: foreground-set
      family-set -> gboolean: family-set
      style-set -> gboolean: style-set
      variant-set -> gboolean: variant-set
      weight-set -> gboolean: weight-set
      stretch-set -> gboolean: stretch-set
      size-set -> gboolean: size-set
      scale-set -> gboolean: scale-set
      editable-set -> gboolean: editable-set
      strikethrough-set -> gboolean: strikethrough-set
      underline-set -> gboolean: underline-set
      rise-set -> gboolean: rise-set
      language-set -> gboolean: language-set
      ellipsize-set -> gboolean: ellipsize-set
      align-set -> gboolean: align-set

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRendererText.Props):
        has_entry: bool
        model: TreeModel
        text_column: int
        align_set: bool
        alignment: Pango.Alignment
        attributes: Pango.AttrList
        background_rgba: Gdk.RGBA
        background_set: bool
        editable: bool
        editable_set: bool
        ellipsize: Pango.EllipsizeMode
        ellipsize_set: bool
        family: str
        family_set: bool
        font: str
        font_desc: Pango.FontDescription
        foreground_rgba: Gdk.RGBA
        foreground_set: bool
        language: str
        language_set: bool
        max_width_chars: int
        placeholder_text: str
        rise: int
        rise_set: bool
        scale: float
        scale_set: bool
        single_paragraph_mode: bool
        size: int
        size_points: float
        size_set: bool
        stretch: Pango.Stretch
        stretch_set: bool
        strikethrough: bool
        strikethrough_set: bool
        style: Pango.Style
        style_set: bool
        text: str
        underline: Pango.Underline
        underline_set: bool
        variant: Pango.Variant
        variant_set: bool
        weight: int
        weight_set: bool
        width_chars: int
        wrap_mode: Pango.WrapMode
        wrap_width: int
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        background: str
        foreground: str
        markup: str
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        has_entry: bool = ...,
        model: TreeModel = ...,
        text_column: int = ...,
        align_set: bool = ...,
        alignment: Pango.Alignment = ...,
        attributes: Pango.AttrList = ...,
        background: str = ...,
        background_rgba: Gdk.RGBA = ...,
        background_set: bool = ...,
        editable: bool = ...,
        editable_set: bool = ...,
        ellipsize: Pango.EllipsizeMode = ...,
        ellipsize_set: bool = ...,
        family: str = ...,
        family_set: bool = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        foreground: str = ...,
        foreground_rgba: Gdk.RGBA = ...,
        foreground_set: bool = ...,
        language: str = ...,
        language_set: bool = ...,
        markup: str = ...,
        max_width_chars: int = ...,
        placeholder_text: str = ...,
        rise: int = ...,
        rise_set: bool = ...,
        scale: float = ...,
        scale_set: bool = ...,
        single_paragraph_mode: bool = ...,
        size: int = ...,
        size_points: float = ...,
        size_set: bool = ...,
        stretch: Pango.Stretch = ...,
        stretch_set: bool = ...,
        strikethrough: bool = ...,
        strikethrough_set: bool = ...,
        style: Pango.Style = ...,
        style_set: bool = ...,
        text: str = ...,
        underline: Pango.Underline = ...,
        underline_set: bool = ...,
        variant: Pango.Variant = ...,
        variant_set: bool = ...,
        weight: int = ...,
        weight_set: bool = ...,
        width_chars: int = ...,
        wrap_mode: Pango.WrapMode = ...,
        wrap_width: int = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> CellRendererCombo: ...

class CellRendererPixbuf(CellRenderer):
    """
    :Constructors:

    ::

        CellRendererPixbuf(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererPixbuf

    Properties from GtkCellRendererPixbuf:
      pixbuf -> GdkPixbuf: pixbuf
      pixbuf-expander-open -> GdkPixbuf: pixbuf-expander-open
      pixbuf-expander-closed -> GdkPixbuf: pixbuf-expander-closed
      texture -> GdkTexture: texture
      icon-size -> GtkIconSize: icon-size
      icon-name -> gchararray: icon-name
      gicon -> GIcon: gicon

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRenderer.Props):
        gicon: Gio.Icon
        icon_name: str
        icon_size: IconSize
        pixbuf_expander_closed: GdkPixbuf.Pixbuf
        pixbuf_expander_open: GdkPixbuf.Pixbuf
        texture: Gdk.Texture
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        pixbuf: GdkPixbuf.Pixbuf
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        gicon: Gio.Icon = ...,
        icon_name: str = ...,
        icon_size: IconSize = ...,
        pixbuf: GdkPixbuf.Pixbuf = ...,
        pixbuf_expander_closed: GdkPixbuf.Pixbuf = ...,
        pixbuf_expander_open: GdkPixbuf.Pixbuf = ...,
        texture: Gdk.Texture = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> CellRendererPixbuf: ...

class CellRendererPrivate(GObject.GPointer): ...

class CellRendererProgress(CellRenderer, Orientable):
    """
    :Constructors:

    ::

        CellRendererProgress(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererProgress

    Properties from GtkCellRendererProgress:
      value -> gint: value
      text -> gchararray: text
      pulse -> gint: pulse
      text-xalign -> gfloat: text-xalign
      text-yalign -> gfloat: text-yalign
      inverted -> gboolean: inverted

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRenderer.Props):
        inverted: bool
        pulse: int
        text: str
        text_xalign: float
        text_yalign: float
        value: int
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        orientation: Orientation
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        inverted: bool = ...,
        pulse: int = ...,
        text: str = ...,
        text_xalign: float = ...,
        text_yalign: float = ...,
        value: int = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> CellRendererProgress: ...

class CellRendererSpin(CellRendererText):
    """
    :Constructors:

    ::

        CellRendererSpin(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererSpin

    Properties from GtkCellRendererSpin:
      adjustment -> GtkAdjustment: adjustment
      climb-rate -> gdouble: climb-rate
      digits -> guint: digits

    Signals from GtkCellRendererText:
      edited (gchararray, gchararray)

    Properties from GtkCellRendererText:
      text -> gchararray: text
      markup -> gchararray: markup
      attributes -> PangoAttrList: attributes
      single-paragraph-mode -> gboolean: single-paragraph-mode
      width-chars -> gint: width-chars
      max-width-chars -> gint: max-width-chars
      wrap-width -> gint: wrap-width
      alignment -> PangoAlignment: alignment
      placeholder-text -> gchararray: placeholder-text
      background -> gchararray: background
      foreground -> gchararray: foreground
      background-rgba -> GdkRGBA: background-rgba
      foreground-rgba -> GdkRGBA: foreground-rgba
      font -> gchararray: font
      font-desc -> PangoFontDescription: font-desc
      family -> gchararray: family
      style -> PangoStyle: style
      variant -> PangoVariant: variant
      weight -> gint: weight
      stretch -> PangoStretch: stretch
      size -> gint: size
      size-points -> gdouble: size-points
      scale -> gdouble: scale
      editable -> gboolean: editable
      strikethrough -> gboolean: strikethrough
      underline -> PangoUnderline: underline
      rise -> gint: rise
      language -> gchararray: language
      ellipsize -> PangoEllipsizeMode: ellipsize
      wrap-mode -> PangoWrapMode: wrap-mode
      background-set -> gboolean: background-set
      foreground-set -> gboolean: foreground-set
      family-set -> gboolean: family-set
      style-set -> gboolean: style-set
      variant-set -> gboolean: variant-set
      weight-set -> gboolean: weight-set
      stretch-set -> gboolean: stretch-set
      size-set -> gboolean: size-set
      scale-set -> gboolean: scale-set
      editable-set -> gboolean: editable-set
      strikethrough-set -> gboolean: strikethrough-set
      underline-set -> gboolean: underline-set
      rise-set -> gboolean: rise-set
      language-set -> gboolean: language-set
      ellipsize-set -> gboolean: ellipsize-set
      align-set -> gboolean: align-set

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRendererText.Props):
        adjustment: Adjustment
        climb_rate: float
        digits: int
        align_set: bool
        alignment: Pango.Alignment
        attributes: Pango.AttrList
        background_rgba: Gdk.RGBA
        background_set: bool
        editable: bool
        editable_set: bool
        ellipsize: Pango.EllipsizeMode
        ellipsize_set: bool
        family: str
        family_set: bool
        font: str
        font_desc: Pango.FontDescription
        foreground_rgba: Gdk.RGBA
        foreground_set: bool
        language: str
        language_set: bool
        max_width_chars: int
        placeholder_text: str
        rise: int
        rise_set: bool
        scale: float
        scale_set: bool
        single_paragraph_mode: bool
        size: int
        size_points: float
        size_set: bool
        stretch: Pango.Stretch
        stretch_set: bool
        strikethrough: bool
        strikethrough_set: bool
        style: Pango.Style
        style_set: bool
        text: str
        underline: Pango.Underline
        underline_set: bool
        variant: Pango.Variant
        variant_set: bool
        weight: int
        weight_set: bool
        width_chars: int
        wrap_mode: Pango.WrapMode
        wrap_width: int
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        background: str
        foreground: str
        markup: str
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        adjustment: Adjustment = ...,
        climb_rate: float = ...,
        digits: int = ...,
        align_set: bool = ...,
        alignment: Pango.Alignment = ...,
        attributes: Pango.AttrList = ...,
        background: str = ...,
        background_rgba: Gdk.RGBA = ...,
        background_set: bool = ...,
        editable: bool = ...,
        editable_set: bool = ...,
        ellipsize: Pango.EllipsizeMode = ...,
        ellipsize_set: bool = ...,
        family: str = ...,
        family_set: bool = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        foreground: str = ...,
        foreground_rgba: Gdk.RGBA = ...,
        foreground_set: bool = ...,
        language: str = ...,
        language_set: bool = ...,
        markup: str = ...,
        max_width_chars: int = ...,
        placeholder_text: str = ...,
        rise: int = ...,
        rise_set: bool = ...,
        scale: float = ...,
        scale_set: bool = ...,
        single_paragraph_mode: bool = ...,
        size: int = ...,
        size_points: float = ...,
        size_set: bool = ...,
        stretch: Pango.Stretch = ...,
        stretch_set: bool = ...,
        strikethrough: bool = ...,
        strikethrough_set: bool = ...,
        style: Pango.Style = ...,
        style_set: bool = ...,
        text: str = ...,
        underline: Pango.Underline = ...,
        underline_set: bool = ...,
        variant: Pango.Variant = ...,
        variant_set: bool = ...,
        weight: int = ...,
        weight_set: bool = ...,
        width_chars: int = ...,
        wrap_mode: Pango.WrapMode = ...,
        wrap_width: int = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> CellRendererSpin: ...

class CellRendererSpinner(CellRenderer):
    """
    :Constructors:

    ::

        CellRendererSpinner(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererSpinner

    Properties from GtkCellRendererSpinner:
      active -> gboolean: active
      pulse -> guint: pulse
      size -> GtkIconSize: size

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRenderer.Props):
        active: bool
        pulse: int
        size: IconSize
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        active: bool = ...,
        pulse: int = ...,
        size: IconSize = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> CellRendererSpinner: ...

class CellRendererText(CellRenderer):
    """
    :Constructors:

    ::

        CellRendererText(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererText

    Signals from GtkCellRendererText:
      edited (gchararray, gchararray)

    Properties from GtkCellRendererText:
      text -> gchararray: text
      markup -> gchararray: markup
      attributes -> PangoAttrList: attributes
      single-paragraph-mode -> gboolean: single-paragraph-mode
      width-chars -> gint: width-chars
      max-width-chars -> gint: max-width-chars
      wrap-width -> gint: wrap-width
      alignment -> PangoAlignment: alignment
      placeholder-text -> gchararray: placeholder-text
      background -> gchararray: background
      foreground -> gchararray: foreground
      background-rgba -> GdkRGBA: background-rgba
      foreground-rgba -> GdkRGBA: foreground-rgba
      font -> gchararray: font
      font-desc -> PangoFontDescription: font-desc
      family -> gchararray: family
      style -> PangoStyle: style
      variant -> PangoVariant: variant
      weight -> gint: weight
      stretch -> PangoStretch: stretch
      size -> gint: size
      size-points -> gdouble: size-points
      scale -> gdouble: scale
      editable -> gboolean: editable
      strikethrough -> gboolean: strikethrough
      underline -> PangoUnderline: underline
      rise -> gint: rise
      language -> gchararray: language
      ellipsize -> PangoEllipsizeMode: ellipsize
      wrap-mode -> PangoWrapMode: wrap-mode
      background-set -> gboolean: background-set
      foreground-set -> gboolean: foreground-set
      family-set -> gboolean: family-set
      style-set -> gboolean: style-set
      variant-set -> gboolean: variant-set
      weight-set -> gboolean: weight-set
      stretch-set -> gboolean: stretch-set
      size-set -> gboolean: size-set
      scale-set -> gboolean: scale-set
      editable-set -> gboolean: editable-set
      strikethrough-set -> gboolean: strikethrough-set
      underline-set -> gboolean: underline-set
      rise-set -> gboolean: rise-set
      language-set -> gboolean: language-set
      ellipsize-set -> gboolean: ellipsize-set
      align-set -> gboolean: align-set

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRenderer.Props):
        align_set: bool
        alignment: Pango.Alignment
        attributes: Pango.AttrList
        background_rgba: Gdk.RGBA
        background_set: bool
        editable: bool
        editable_set: bool
        ellipsize: Pango.EllipsizeMode
        ellipsize_set: bool
        family: str
        family_set: bool
        font: str
        font_desc: Pango.FontDescription
        foreground_rgba: Gdk.RGBA
        foreground_set: bool
        language: str
        language_set: bool
        max_width_chars: int
        placeholder_text: str
        rise: int
        rise_set: bool
        scale: float
        scale_set: bool
        single_paragraph_mode: bool
        size: int
        size_points: float
        size_set: bool
        stretch: Pango.Stretch
        stretch_set: bool
        strikethrough: bool
        strikethrough_set: bool
        style: Pango.Style
        style_set: bool
        text: str
        underline: Pango.Underline
        underline_set: bool
        variant: Pango.Variant
        variant_set: bool
        weight: int
        weight_set: bool
        width_chars: int
        wrap_mode: Pango.WrapMode
        wrap_width: int
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        background: str
        foreground: str
        markup: str
        cell_background: str

    props: Props = ...
    parent: CellRenderer = ...
    def __init__(
        self,
        align_set: bool = ...,
        alignment: Pango.Alignment = ...,
        attributes: Pango.AttrList = ...,
        background: str = ...,
        background_rgba: Gdk.RGBA = ...,
        background_set: bool = ...,
        editable: bool = ...,
        editable_set: bool = ...,
        ellipsize: Pango.EllipsizeMode = ...,
        ellipsize_set: bool = ...,
        family: str = ...,
        family_set: bool = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        foreground: str = ...,
        foreground_rgba: Gdk.RGBA = ...,
        foreground_set: bool = ...,
        language: str = ...,
        language_set: bool = ...,
        markup: str = ...,
        max_width_chars: int = ...,
        placeholder_text: str = ...,
        rise: int = ...,
        rise_set: bool = ...,
        scale: float = ...,
        scale_set: bool = ...,
        single_paragraph_mode: bool = ...,
        size: int = ...,
        size_points: float = ...,
        size_set: bool = ...,
        stretch: Pango.Stretch = ...,
        stretch_set: bool = ...,
        strikethrough: bool = ...,
        strikethrough_set: bool = ...,
        style: Pango.Style = ...,
        style_set: bool = ...,
        text: str = ...,
        underline: Pango.Underline = ...,
        underline_set: bool = ...,
        variant: Pango.Variant = ...,
        variant_set: bool = ...,
        weight: int = ...,
        weight_set: bool = ...,
        width_chars: int = ...,
        wrap_mode: Pango.WrapMode = ...,
        wrap_width: int = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    def do_edited(self, path: str, new_text: str) -> None: ...
    @classmethod
    def new(cls) -> CellRendererText: ...
    def set_fixed_height_from_font(self, number_of_rows: int) -> None: ...

class CellRendererTextClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CellRendererTextClass()
    """

    parent_class: CellRendererClass = ...
    edited: typing.Callable[[CellRendererText, str, str], None] = ...
    padding: list[None] = ...

class CellRendererToggle(CellRenderer):
    """
    :Constructors:

    ::

        CellRendererToggle(**properties)
        new() -> Gtk.CellRenderer

    Object GtkCellRendererToggle

    Signals from GtkCellRendererToggle:
      toggled (gchararray)

    Properties from GtkCellRendererToggle:
      activatable -> gboolean: activatable
      active -> gboolean: active
      radio -> gboolean: radio
      inconsistent -> gboolean: inconsistent

    Signals from GtkCellRenderer:
      editing-canceled ()
      editing-started (GtkCellEditable, gchararray)

    Properties from GtkCellRenderer:
      mode -> GtkCellRendererMode: mode
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      xpad -> guint: xpad
      ypad -> guint: ypad
      width -> gint: width
      height -> gint: height
      is-expander -> gboolean: is-expander
      is-expanded -> gboolean: is-expanded
      cell-background -> gchararray: cell-background
      cell-background-rgba -> GdkRGBA: cell-background-rgba
      cell-background-set -> gboolean: cell-background-set
      editing -> gboolean: editing

    Signals from GObject:
      notify (GParam)
    """
    class Props(CellRenderer.Props):
        activatable: bool
        active: bool
        inconsistent: bool
        radio: bool
        cell_background_rgba: Gdk.RGBA
        cell_background_set: bool
        editing: bool
        height: int
        is_expanded: bool
        is_expander: bool
        mode: CellRendererMode
        sensitive: bool
        visible: bool
        width: int
        xalign: float
        xpad: int
        yalign: float
        ypad: int
        cell_background: str

    props: Props = ...
    def __init__(
        self,
        activatable: bool = ...,
        active: bool = ...,
        inconsistent: bool = ...,
        radio: bool = ...,
        cell_background: str = ...,
        cell_background_rgba: Gdk.RGBA = ...,
        cell_background_set: bool = ...,
        height: int = ...,
        is_expanded: bool = ...,
        is_expander: bool = ...,
        mode: CellRendererMode = ...,
        sensitive: bool = ...,
        visible: bool = ...,
        width: int = ...,
        xalign: float = ...,
        xpad: int = ...,
        yalign: float = ...,
        ypad: int = ...,
    ) -> None: ...
    def get_activatable(self) -> bool: ...
    def get_active(self) -> bool: ...
    def get_radio(self) -> bool: ...
    @classmethod
    def new(cls) -> CellRendererToggle: ...
    def set_activatable(self, setting: bool) -> None: ...
    def set_active(self, setting: bool) -> None: ...
    def set_radio(self, radio: bool) -> None: ...

class CellView(Widget, Accessible, Buildable, CellLayout, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        CellView(**properties)
        new() -> Gtk.Widget
        new_with_context(area:Gtk.CellArea, context:Gtk.CellAreaContext) -> Gtk.Widget
        new_with_markup(markup:str) -> Gtk.Widget
        new_with_text(text:str) -> Gtk.Widget
        new_with_texture(texture:Gdk.Texture) -> Gtk.Widget

    Object GtkCellView

    Properties from GtkCellView:
      model -> GtkTreeModel: model
      cell-area -> GtkCellArea: cell-area
      cell-area-context -> GtkCellAreaContext: cell-area-context
      draw-sensitive -> gboolean: draw-sensitive
      fit-model -> gboolean: fit-model

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        cell_area: CellArea
        cell_area_context: CellAreaContext
        draw_sensitive: bool
        fit_model: bool
        model: typing.Optional[TreeModel]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        cell_area: CellArea = ...,
        cell_area_context: CellAreaContext = ...,
        draw_sensitive: bool = ...,
        fit_model: bool = ...,
        model: typing.Optional[TreeModel] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_displayed_row(self) -> typing.Optional[TreePath]: ...
    def get_draw_sensitive(self) -> bool: ...
    def get_fit_model(self) -> bool: ...
    def get_model(self) -> typing.Optional[TreeModel]: ...
    @classmethod
    def new(cls) -> CellView: ...
    @classmethod
    def new_with_context(cls, area: CellArea, context: CellAreaContext) -> CellView: ...
    @classmethod
    def new_with_markup(cls, markup: str) -> CellView: ...
    @classmethod
    def new_with_text(cls, text: str) -> CellView: ...
    @classmethod
    def new_with_texture(cls, texture: Gdk.Texture) -> CellView: ...
    def set_displayed_row(self, path: typing.Optional[TreePath] = None) -> None: ...
    def set_draw_sensitive(self, draw_sensitive: bool) -> None: ...
    def set_fit_model(self, fit_model: bool) -> None: ...
    def set_model(self, model: typing.Optional[TreeModel] = None) -> None: ...

class CenterBox(Widget, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        CenterBox(**properties)
        new() -> Gtk.Widget

    Object GtkCenterBox

    Properties from GtkCenterBox:
      start-widget -> GtkWidget: start-widget
      center-widget -> GtkWidget: center-widget
      end-widget -> GtkWidget: end-widget
      baseline-position -> GtkBaselinePosition: baseline-position
      shrink-center-last -> gboolean: shrink-center-last

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        baseline_position: BaselinePosition
        center_widget: typing.Optional[Widget]
        end_widget: typing.Optional[Widget]
        shrink_center_last: bool
        start_widget: typing.Optional[Widget]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        baseline_position: BaselinePosition = ...,
        center_widget: typing.Optional[Widget] = ...,
        end_widget: typing.Optional[Widget] = ...,
        shrink_center_last: bool = ...,
        start_widget: typing.Optional[Widget] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_baseline_position(self) -> BaselinePosition: ...
    def get_center_widget(self) -> typing.Optional[Widget]: ...
    def get_end_widget(self) -> typing.Optional[Widget]: ...
    def get_shrink_center_last(self) -> bool: ...
    def get_start_widget(self) -> typing.Optional[Widget]: ...
    @classmethod
    def new(cls) -> CenterBox: ...
    def set_baseline_position(self, position: BaselinePosition) -> None: ...
    def set_center_widget(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_end_widget(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_shrink_center_last(self, shrink_center_last: bool) -> None: ...
    def set_start_widget(self, child: typing.Optional[Widget] = None) -> None: ...

class CenterBoxClass(GObject.GPointer): ...

class CenterLayout(LayoutManager):
    """
    :Constructors:

    ::

        CenterLayout(**properties)
        new() -> Gtk.LayoutManager

    Object GtkCenterLayout

    Properties from GtkCenterLayout:
      shrink-center-last -> gboolean: shrink-center-last

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutManager.Props):
        shrink_center_last: bool

    props: Props = ...
    def __init__(self, shrink_center_last: bool = ...) -> None: ...
    def get_baseline_position(self) -> BaselinePosition: ...
    def get_center_widget(self) -> typing.Optional[Widget]: ...
    def get_end_widget(self) -> typing.Optional[Widget]: ...
    def get_orientation(self) -> Orientation: ...
    def get_shrink_center_last(self) -> bool: ...
    def get_start_widget(self) -> typing.Optional[Widget]: ...
    @classmethod
    def new(cls) -> CenterLayout: ...
    def set_baseline_position(self, baseline_position: BaselinePosition) -> None: ...
    def set_center_widget(self, widget: typing.Optional[Widget] = None) -> None: ...
    def set_end_widget(self, widget: typing.Optional[Widget] = None) -> None: ...
    def set_orientation(self, orientation: Orientation) -> None: ...
    def set_shrink_center_last(self, shrink_center_last: bool) -> None: ...
    def set_start_widget(self, widget: typing.Optional[Widget] = None) -> None: ...

class CenterLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CenterLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class CheckButton(Widget, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        CheckButton(**properties)
        new() -> Gtk.Widget
        new_with_label(label:str=None) -> Gtk.Widget
        new_with_mnemonic(label:str=None) -> Gtk.Widget

    Object GtkCheckButton

    Signals from GtkCheckButton:
      activate ()
      toggled ()

    Properties from GtkCheckButton:
      active -> gboolean: active
      group -> GtkCheckButton: group
      label -> gchararray: label
      inconsistent -> gboolean: inconsistent
      use-underline -> gboolean: use-underline
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        active: bool
        child: typing.Optional[Widget]
        inconsistent: bool
        label: typing.Optional[str]
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant
        group: typing.Optional[CheckButton]

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        active: bool = ...,
        child: typing.Optional[Widget] = ...,
        group: typing.Optional[CheckButton] = ...,
        inconsistent: bool = ...,
        label: typing.Optional[str] = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def do_activate(self) -> None: ...
    def do_toggled(self) -> None: ...
    def get_active(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_inconsistent(self) -> bool: ...
    def get_label(self) -> typing.Optional[str]: ...
    def get_use_underline(self) -> bool: ...
    @classmethod
    def new(cls) -> CheckButton: ...
    @classmethod
    def new_with_label(cls, label: typing.Optional[str] = None) -> CheckButton: ...
    @classmethod
    def new_with_mnemonic(cls, label: typing.Optional[str] = None) -> CheckButton: ...
    def set_active(self, setting: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_group(self, group: typing.Optional[CheckButton] = None) -> None: ...
    def set_inconsistent(self, inconsistent: bool) -> None: ...
    def set_label(self, label: typing.Optional[str] = None) -> None: ...
    def set_use_underline(self, setting: bool) -> None: ...

class CheckButtonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CheckButtonClass()
    """

    parent_class: WidgetClass = ...
    toggled: typing.Callable[[CheckButton], None] = ...
    activate: typing.Callable[[CheckButton], None] = ...
    padding: list[None] = ...

class ClosureExpression(Expression):
    """
    :Constructors:

    ::

        ClosureExpression(**properties)
        new(value_type:GType, closure:GObject.Closure, params:list=None) -> Gtk.ClosureExpression
    """
    @classmethod
    def new(
        cls,
        value_type: typing.Type[typing.Any],
        closure: typing.Callable[..., typing.Any],
        params: typing.Optional[typing.Sequence[Expression]] = None,
    ) -> ClosureExpression: ...

class ColorButton(Widget, Accessible, Buildable, ColorChooser, ConstraintTarget):
    """
    :Constructors:

    ::

        ColorButton(**properties)
        new() -> Gtk.Widget
        new_with_rgba(rgba:Gdk.RGBA) -> Gtk.Widget

    Object GtkColorButton

    Signals from GtkColorButton:
      activate ()
      color-set ()

    Properties from GtkColorButton:
      title -> gchararray: title
      show-editor -> gboolean: show-editor
      modal -> gboolean: modal

    Signals from GtkColorChooser:
      color-activated (GdkRGBA)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        modal: bool
        show_editor: bool
        title: str
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        rgba: Gdk.RGBA
        use_alpha: bool

    props: Props = ...
    def __init__(
        self,
        modal: bool = ...,
        show_editor: bool = ...,
        title: str = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        rgba: Gdk.RGBA = ...,
        use_alpha: bool = ...,
    ) -> None: ...
    def get_modal(self) -> bool: ...
    def get_title(self) -> str: ...
    @classmethod
    def new(cls) -> ColorButton: ...
    @classmethod
    def new_with_rgba(cls, rgba: Gdk.RGBA) -> ColorButton: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_title(self, title: str) -> None: ...

class ColorChooser(GObject.GInterface):
    """
    Interface GtkColorChooser

    Signals from GObject:
      notify (GParam)
    """
    def add_palette(
        self,
        orientation: Orientation,
        colors_per_line: int,
        colors: typing.Optional[typing.Sequence[Gdk.RGBA]] = None,
    ) -> None: ...
    def get_rgba(self) -> Gdk.RGBA: ...
    def get_use_alpha(self) -> bool: ...
    def set_rgba(self, color: Gdk.RGBA) -> None: ...
    def set_use_alpha(self, use_alpha: bool) -> None: ...

class ColorChooserDialog(
    Dialog,
    Accessible,
    Buildable,
    ColorChooser,
    ConstraintTarget,
    Native,
    Root,
    ShortcutManager,
):
    """
    :Constructors:

    ::

        ColorChooserDialog(**properties)
        new(title:str=None, parent:Gtk.Window=None) -> Gtk.Widget

    Object GtkColorChooserDialog

    Properties from GtkColorChooserDialog:
      show-editor -> gboolean: show-editor

    Signals from GtkColorChooser:
      color-activated (GdkRGBA)

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Dialog.Props):
        show_editor: bool
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        rgba: Gdk.RGBA
        use_alpha: bool
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        show_editor: bool = ...,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        rgba: Gdk.RGBA = ...,
        use_alpha: bool = ...,
    ) -> None: ...
    @classmethod
    def new(
        cls, title: typing.Optional[str] = None, parent: typing.Optional[Window] = None
    ) -> ColorChooserDialog: ...

class ColorChooserInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ColorChooserInterface()
    """

    base_interface: GObject.TypeInterface = ...
    get_rgba: typing.Callable[[ColorChooser], Gdk.RGBA] = ...
    set_rgba: typing.Callable[[ColorChooser, Gdk.RGBA], None] = ...
    add_palette: typing.Callable[
        [ColorChooser, Orientation, int, typing.Optional[typing.Sequence[Gdk.RGBA]]],
        None,
    ] = ...
    color_activated: typing.Callable[[ColorChooser, Gdk.RGBA], None] = ...
    padding: list[None] = ...

class ColorChooserWidget(Widget, Accessible, Buildable, ColorChooser, ConstraintTarget):
    """
    :Constructors:

    ::

        ColorChooserWidget(**properties)
        new() -> Gtk.Widget

    Object GtkColorChooserWidget

    Properties from GtkColorChooserWidget:
      show-editor -> gboolean: show-editor

    Signals from GtkColorChooser:
      color-activated (GdkRGBA)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        show_editor: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        rgba: Gdk.RGBA
        use_alpha: bool

    props: Props = ...
    def __init__(
        self,
        show_editor: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        rgba: Gdk.RGBA = ...,
        use_alpha: bool = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> ColorChooserWidget: ...

class ColorDialog(GObject.Object):
    """
    :Constructors:

    ::

        ColorDialog(**properties)
        new() -> Gtk.ColorDialog

    Object GtkColorDialog

    Properties from GtkColorDialog:
      title -> gchararray: title
      modal -> gboolean: modal
      with-alpha -> gboolean: with-alpha

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        modal: bool
        title: str
        with_alpha: bool

    props: Props = ...
    def __init__(
        self, modal: bool = ..., title: str = ..., with_alpha: bool = ...
    ) -> None: ...
    def choose_rgba(
        self,
        parent: typing.Optional[Window] = None,
        initial_color: typing.Optional[Gdk.RGBA] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def choose_rgba_finish(self, result: Gio.AsyncResult) -> Gdk.RGBA: ...
    def get_modal(self) -> bool: ...
    def get_title(self) -> str: ...
    def get_with_alpha(self) -> bool: ...
    @classmethod
    def new(cls) -> ColorDialog: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_title(self, title: str) -> None: ...
    def set_with_alpha(self, with_alpha: bool) -> None: ...

class ColorDialogButton(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ColorDialogButton(**properties)
        new(dialog:Gtk.ColorDialog=None) -> Gtk.Widget

    Object GtkColorDialogButton

    Signals from GtkColorDialogButton:
      activate ()

    Properties from GtkColorDialogButton:
      dialog -> GtkColorDialog: dialog
      rgba -> GdkRGBA: rgba

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        dialog: typing.Optional[ColorDialog]
        rgba: Gdk.RGBA
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        dialog: ColorDialog = ...,
        rgba: Gdk.RGBA = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_dialog(self) -> typing.Optional[ColorDialog]: ...
    def get_rgba(self) -> Gdk.RGBA: ...
    @classmethod
    def new(cls, dialog: typing.Optional[ColorDialog] = None) -> ColorDialogButton: ...
    def set_dialog(self, dialog: ColorDialog) -> None: ...
    def set_rgba(self, color: Gdk.RGBA) -> None: ...

class ColorDialogButtonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ColorDialogButtonClass()
    """

    parent_class: WidgetClass = ...

class ColorDialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ColorDialogClass()
    """

    parent_class: GObject.ObjectClass = ...

class ColumnView(Widget, Accessible, Buildable, ConstraintTarget, Scrollable):
    """
    :Constructors:

    ::

        ColumnView(**properties)
        new(model:Gtk.SelectionModel=None) -> Gtk.Widget

    Object GtkColumnView

    Signals from GtkColumnView:
      activate (guint)

    Properties from GtkColumnView:
      columns -> GListModel: columns
      enable-rubberband -> gboolean: enable-rubberband
      header-factory -> GtkListItemFactory: header-factory
      model -> GtkSelectionModel: model
      reorderable -> gboolean: reorderable
      row-factory -> GtkListItemFactory: row-factory
      show-row-separators -> gboolean: show-row-separators
      show-column-separators -> gboolean: show-column-separators
      single-click-activate -> gboolean: single-click-activate
      sorter -> GtkSorter: sorter
      tab-behavior -> GtkListTabBehavior: tab-behavior

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(Widget.Props):
        columns: Gio.ListModel[typing.Any]
        enable_rubberband: bool
        header_factory: typing.Optional[ListItemFactory]
        model: typing.Optional[SelectionModel]
        reorderable: bool
        row_factory: typing.Optional[ListItemFactory]
        show_column_separators: bool
        show_row_separators: bool
        single_click_activate: bool
        sorter: typing.Optional[Sorter]
        tab_behavior: ListTabBehavior
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    def __init__(
        self,
        enable_rubberband: bool = ...,
        header_factory: typing.Optional[ListItemFactory] = ...,
        model: typing.Optional[SelectionModel] = ...,
        reorderable: bool = ...,
        row_factory: typing.Optional[ListItemFactory] = ...,
        show_column_separators: bool = ...,
        show_row_separators: bool = ...,
        single_click_activate: bool = ...,
        tab_behavior: ListTabBehavior = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def append_column(self, column: ColumnViewColumn) -> None: ...
    # override
    def get_columns(self) -> Gio.ListModel[typing.Any]: ...
    def get_enable_rubberband(self) -> bool: ...
    def get_header_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_model(self) -> typing.Optional[SelectionModel]: ...
    def get_reorderable(self) -> bool: ...
    def get_row_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_show_column_separators(self) -> bool: ...
    def get_show_row_separators(self) -> bool: ...
    def get_single_click_activate(self) -> bool: ...
    def get_sorter(self) -> typing.Optional[Sorter]: ...
    def get_tab_behavior(self) -> ListTabBehavior: ...
    def insert_column(self, position: int, column: ColumnViewColumn) -> None: ...
    @classmethod
    def new(cls, model: typing.Optional[SelectionModel] = None) -> ColumnView: ...
    def remove_column(self, column: ColumnViewColumn) -> None: ...
    def scroll_to(
        self,
        pos: int,
        column: typing.Optional[ColumnViewColumn],
        flags: ListScrollFlags,
        scroll: typing.Optional[ScrollInfo] = None,
    ) -> None: ...
    def set_enable_rubberband(self, enable_rubberband: bool) -> None: ...
    def set_header_factory(
        self, factory: typing.Optional[ListItemFactory] = None
    ) -> None: ...
    def set_model(self, model: typing.Optional[SelectionModel] = None) -> None: ...
    def set_reorderable(self, reorderable: bool) -> None: ...
    def set_row_factory(
        self, factory: typing.Optional[ListItemFactory] = None
    ) -> None: ...
    def set_show_column_separators(self, show_column_separators: bool) -> None: ...
    def set_show_row_separators(self, show_row_separators: bool) -> None: ...
    def set_single_click_activate(self, single_click_activate: bool) -> None: ...
    def set_tab_behavior(self, tab_behavior: ListTabBehavior) -> None: ...
    def sort_by_column(
        self, column: typing.Optional[ColumnViewColumn], direction: SortType
    ) -> None: ...

class ColumnViewCell(ListItem):
    """
    :Constructors:

    ::

        ColumnViewCell(**properties)

    Object GtkColumnViewCell

    Properties from GtkColumnViewCell:
      child -> GtkWidget: child
      focusable -> gboolean: focusable
      item -> GObject: item
      position -> guint: position
      selected -> gboolean: selected

    Properties from GtkListItem:
      accessible-description -> gchararray: accessible-description
      accessible-label -> gchararray: accessible-label
      activatable -> gboolean: activatable
      child -> GtkWidget: child
      focusable -> gboolean: focusable
      item -> GObject: item
      position -> guint: position
      selectable -> gboolean: selectable
      selected -> gboolean: selected

    Signals from GObject:
      notify (GParam)
    """
    class Props(ListItem.Props):
        child: typing.Optional[Widget]
        focusable: bool
        item: typing.Optional[GObject.Object]
        position: int
        selected: bool
        accessible_description: str
        accessible_label: str
        activatable: bool
        selectable: bool

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        focusable: bool = ...,
        accessible_description: str = ...,
        accessible_label: str = ...,
        activatable: bool = ...,
        selectable: bool = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_focusable(self) -> bool: ...
    def get_item(self) -> typing.Optional[GObject.Object]: ...
    def get_position(self) -> int: ...
    def get_selected(self) -> bool: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_focusable(self, focusable: bool) -> None: ...

class ColumnViewCellClass(GObject.GPointer): ...
class ColumnViewClass(GObject.GPointer): ...

class ColumnViewColumn(GObject.Object):
    """
    :Constructors:

    ::

        ColumnViewColumn(**properties)
        new(title:str=None, factory:Gtk.ListItemFactory=None) -> Gtk.ColumnViewColumn

    Object GtkColumnViewColumn

    Properties from GtkColumnViewColumn:
      column-view -> GtkColumnView: column-view
      factory -> GtkListItemFactory: factory
      title -> gchararray: title
      sorter -> GtkSorter: sorter
      visible -> gboolean: visible
      header-menu -> GMenuModel: header-menu
      resizable -> gboolean: resizable
      expand -> gboolean: expand
      fixed-width -> gint: fixed-width
      id -> gchararray: id

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        column_view: typing.Optional[ColumnView]
        expand: bool
        factory: typing.Optional[ListItemFactory]
        fixed_width: int
        header_menu: typing.Optional[Gio.MenuModel]
        id: typing.Optional[str]
        resizable: bool
        sorter: typing.Optional[Sorter]
        title: typing.Optional[str]
        visible: bool

    props: Props = ...
    def __init__(
        self,
        expand: bool = ...,
        factory: typing.Optional[ListItemFactory] = ...,
        fixed_width: int = ...,
        header_menu: typing.Optional[Gio.MenuModel] = ...,
        id: typing.Optional[str] = ...,
        resizable: bool = ...,
        sorter: typing.Optional[Sorter] = ...,
        title: typing.Optional[str] = ...,
        visible: bool = ...,
    ) -> None: ...
    def get_column_view(self) -> typing.Optional[ColumnView]: ...
    def get_expand(self) -> bool: ...
    def get_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_fixed_width(self) -> int: ...
    def get_header_menu(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_id(self) -> typing.Optional[str]: ...
    def get_resizable(self) -> bool: ...
    def get_sorter(self) -> typing.Optional[Sorter]: ...
    def get_title(self) -> typing.Optional[str]: ...
    def get_visible(self) -> bool: ...
    @classmethod
    def new(
        cls,
        title: typing.Optional[str] = None,
        factory: typing.Optional[ListItemFactory] = None,
    ) -> ColumnViewColumn: ...
    def set_expand(self, expand: bool) -> None: ...
    def set_factory(self, factory: typing.Optional[ListItemFactory] = None) -> None: ...
    def set_fixed_width(self, fixed_width: int) -> None: ...
    def set_header_menu(self, menu: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def set_id(self, id: typing.Optional[str] = None) -> None: ...
    def set_resizable(self, resizable: bool) -> None: ...
    def set_sorter(self, sorter: typing.Optional[Sorter] = None) -> None: ...
    def set_title(self, title: typing.Optional[str] = None) -> None: ...
    def set_visible(self, visible: bool) -> None: ...

class ColumnViewColumnClass(GObject.GPointer): ...

class ColumnViewRow(GObject.Object):
    """
    :Constructors:

    ::

        ColumnViewRow(**properties)

    Object GtkColumnViewRow

    Properties from GtkColumnViewRow:
      accessible-description -> gchararray: accessible-description
      accessible-label -> gchararray: accessible-label
      activatable -> gboolean: activatable
      focusable -> gboolean: focusable
      item -> GObject: item
      position -> guint: position
      selectable -> gboolean: selectable
      selected -> gboolean: selected

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        accessible_description: str
        accessible_label: str
        activatable: bool
        focusable: bool
        item: typing.Optional[GObject.Object]
        position: int
        selectable: bool
        selected: bool

    props: Props = ...
    def __init__(
        self,
        accessible_description: str = ...,
        accessible_label: str = ...,
        activatable: bool = ...,
        focusable: bool = ...,
        selectable: bool = ...,
    ) -> None: ...
    def get_accessible_description(self) -> str: ...
    def get_accessible_label(self) -> str: ...
    def get_activatable(self) -> bool: ...
    def get_focusable(self) -> bool: ...
    def get_item(self) -> typing.Optional[GObject.Object]: ...
    def get_position(self) -> int: ...
    def get_selectable(self) -> bool: ...
    def get_selected(self) -> bool: ...
    def set_accessible_description(self, description: str) -> None: ...
    def set_accessible_label(self, label: str) -> None: ...
    def set_activatable(self, activatable: bool) -> None: ...
    def set_focusable(self, focusable: bool) -> None: ...
    def set_selectable(self, selectable: bool) -> None: ...

class ColumnViewRowClass(GObject.GPointer): ...

class ColumnViewSorter(Sorter):
    """
    :Constructors:

    ::

        ColumnViewSorter(**properties)

    Object GtkColumnViewSorter

    Properties from GtkColumnViewSorter:
      primary-sort-column -> GtkColumnViewColumn: primary-sort-column
      primary-sort-order -> GtkSortType: primary-sort-order

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Sorter.Props):
        primary_sort_column: typing.Optional[ColumnViewColumn]
        primary_sort_order: SortType

    props: Props = ...
    def get_n_sort_columns(self) -> int: ...
    def get_nth_sort_column(
        self, position: int
    ) -> typing.Tuple[typing.Optional[ColumnViewColumn], SortType]: ...
    def get_primary_sort_column(self) -> typing.Optional[ColumnViewColumn]: ...
    def get_primary_sort_order(self) -> SortType: ...

class ColumnViewSorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ColumnViewSorterClass()
    """

    parent_class: SorterClass = ...

class ComboBox(
    Widget, Accessible, Buildable, CellEditable, CellLayout, ConstraintTarget
):
    """
    :Constructors:

    ::

        ComboBox(**properties)
        new() -> Gtk.Widget
        new_with_entry() -> Gtk.Widget
        new_with_model(model:Gtk.TreeModel) -> Gtk.Widget
        new_with_model_and_entry(model:Gtk.TreeModel) -> Gtk.Widget

    Object GtkComboBox

    Signals from GtkComboBox:
      changed ()
      activate ()
      move-active (GtkScrollType)
      popup ()
      popdown () -> gboolean
      format-entry-text (gchararray) -> gchararray

    Properties from GtkComboBox:
      model -> GtkTreeModel: model
      active -> gint: active
      has-frame -> gboolean: has-frame
      popup-shown -> gboolean: popup-shown
      button-sensitivity -> GtkSensitivityType: button-sensitivity
      has-entry -> gboolean: has-entry
      entry-text-column -> gint: entry-text-column
      popup-fixed-width -> gboolean: popup-fixed-width
      id-column -> gint: id-column
      active-id -> gchararray: active-id
      child -> GtkWidget: child

    Signals from GtkCellEditable:
      editing-done ()
      remove-widget ()

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        active: int
        active_id: typing.Optional[str]
        button_sensitivity: SensitivityType
        child: typing.Optional[Widget]
        entry_text_column: int
        has_entry: bool
        has_frame: bool
        id_column: int
        model: typing.Optional[TreeModel]
        popup_fixed_width: bool
        popup_shown: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        editing_canceled: bool

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        active: int = ...,
        active_id: typing.Optional[str] = ...,
        button_sensitivity: SensitivityType = ...,
        child: typing.Optional[Widget] = ...,
        entry_text_column: int = ...,
        has_entry: bool = ...,
        has_frame: bool = ...,
        id_column: int = ...,
        model: typing.Optional[TreeModel] = ...,
        popup_fixed_width: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editing_canceled: bool = ...,
    ) -> None: ...
    def do_activate(self) -> None: ...
    def do_changed(self) -> None: ...
    def do_format_entry_text(self, path: str) -> str: ...
    def get_active(self) -> int: ...
    def get_active_id(self) -> typing.Optional[str]: ...
    def get_active_iter(
        self,
    ) -> typing.Optional[TreeIter]: ...  # CHECK Wrapped function
    def get_button_sensitivity(self) -> SensitivityType: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_entry_text_column(self) -> int: ...
    def get_has_entry(self) -> bool: ...
    def get_id_column(self) -> int: ...
    def get_model(self) -> typing.Optional[TreeModel]: ...
    def get_popup_fixed_width(self) -> bool: ...
    @classmethod
    def new(cls) -> ComboBox: ...
    @classmethod
    def new_with_entry(cls) -> ComboBox: ...
    @classmethod
    def new_with_model(cls, model: TreeModel) -> ComboBox: ...
    @classmethod
    def new_with_model_and_entry(cls, model: TreeModel) -> ComboBox: ...
    def popdown(self) -> None: ...
    def popup(self) -> None: ...
    def popup_for_device(self, device: Gdk.Device) -> None: ...
    def set_active(self, index_: int) -> None: ...
    def set_active_id(self, active_id: typing.Optional[str] = None) -> bool: ...
    def set_active_iter(self, iter: typing.Optional[TreeIter] = None) -> None: ...
    def set_button_sensitivity(self, sensitivity: SensitivityType) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_entry_text_column(self, text_column: int) -> None: ...
    def set_id_column(self, id_column: int) -> None: ...
    def set_model(self, model: typing.Optional[TreeModel] = None) -> None: ...
    def set_popup_fixed_width(self, fixed: bool) -> None: ...
    def set_row_separator_func(
        self,
        func: typing.Optional[typing.Callable[..., bool]] = None,
        *data: typing.Any,
    ) -> None: ...

class ComboBoxClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ComboBoxClass()
    """

    parent_class: WidgetClass = ...
    changed: typing.Callable[[ComboBox], None] = ...
    format_entry_text: typing.Callable[[ComboBox, str], str] = ...
    activate: typing.Callable[[ComboBox], None] = ...
    padding: list[None] = ...

class ComboBoxText(
    ComboBox, Accessible, Buildable, CellEditable, CellLayout, ConstraintTarget
):
    """
    :Constructors:

    ::

        ComboBoxText(**properties)
        new() -> Gtk.Widget
        new_with_entry() -> Gtk.Widget

    Object GtkComboBoxText

    Signals from GtkCellEditable:
      editing-done ()
      remove-widget ()

    Signals from GtkComboBox:
      changed ()
      activate ()
      move-active (GtkScrollType)
      popup ()
      popdown () -> gboolean
      format-entry-text (gchararray) -> gchararray

    Properties from GtkComboBox:
      model -> GtkTreeModel: model
      active -> gint: active
      has-frame -> gboolean: has-frame
      popup-shown -> gboolean: popup-shown
      button-sensitivity -> GtkSensitivityType: button-sensitivity
      has-entry -> gboolean: has-entry
      entry-text-column -> gint: entry-text-column
      popup-fixed-width -> gboolean: popup-fixed-width
      id-column -> gint: id-column
      active-id -> gchararray: active-id
      child -> GtkWidget: child

    Signals from GtkCellEditable:
      editing-done ()
      remove-widget ()

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(ComboBox.Props):
        active: int
        active_id: typing.Optional[str]
        button_sensitivity: SensitivityType
        child: typing.Optional[Widget]
        entry_text_column: int
        has_entry: bool
        has_frame: bool
        id_column: int
        model: typing.Optional[TreeModel]
        popup_fixed_width: bool
        popup_shown: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        editing_canceled: bool

    props: Props = ...
    def __init__(
        self,
        active: int = ...,
        active_id: typing.Optional[str] = ...,
        button_sensitivity: SensitivityType = ...,
        child: typing.Optional[Widget] = ...,
        entry_text_column: int = ...,
        has_entry: bool = ...,
        has_frame: bool = ...,
        id_column: int = ...,
        model: typing.Optional[TreeModel] = ...,
        popup_fixed_width: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editing_canceled: bool = ...,
    ) -> None: ...
    def append(self, id: typing.Optional[str], text: str) -> None: ...
    def append_text(self, text: str) -> None: ...
    def get_active_text(self) -> typing.Optional[str]: ...
    def insert(self, position: int, id: typing.Optional[str], text: str) -> None: ...
    def insert_text(self, position: int, text: str) -> None: ...
    @classmethod
    def new(cls) -> ComboBoxText: ...
    @classmethod
    def new_with_entry(cls) -> ComboBoxText: ...
    def prepend(self, id: typing.Optional[str], text: str) -> None: ...
    def prepend_text(self, text: str) -> None: ...
    def remove(self, position: int) -> None: ...
    def remove_all(self) -> None: ...

class ConstantExpression(Expression):
    """
    :Constructors:

    ::

        ConstantExpression(**properties)
        new_for_value(value:GObject.Value) -> Gtk.ConstantExpression
    """
    def get_value(self) -> typing.Any: ...
    @classmethod
    def new_for_value(cls, value: typing.Any) -> ConstantExpression: ...

class Constraint(GObject.Object):
    """
    :Constructors:

    ::

        Constraint(**properties)
        new(target:Gtk.ConstraintTarget=None, target_attribute:Gtk.ConstraintAttribute, relation:Gtk.ConstraintRelation, source:Gtk.ConstraintTarget=None, source_attribute:Gtk.ConstraintAttribute, multiplier:float, constant:float, strength:int) -> Gtk.Constraint
        new_constant(target:Gtk.ConstraintTarget=None, target_attribute:Gtk.ConstraintAttribute, relation:Gtk.ConstraintRelation, constant:float, strength:int) -> Gtk.Constraint

    Object GtkConstraint

    Properties from GtkConstraint:
      target -> GtkConstraintTarget: target
      target-attribute -> GtkConstraintAttribute: target-attribute
      relation -> GtkConstraintRelation: relation
      source -> GtkConstraintTarget: source
      source-attribute -> GtkConstraintAttribute: source-attribute
      multiplier -> gdouble: multiplier
      constant -> gdouble: constant
      strength -> gint: strength

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        constant: float
        multiplier: float
        relation: ConstraintRelation
        source: typing.Optional[ConstraintTarget]
        source_attribute: ConstraintAttribute
        strength: int
        target: typing.Optional[ConstraintTarget]
        target_attribute: ConstraintAttribute

    props: Props = ...
    def __init__(
        self,
        constant: float = ...,
        multiplier: float = ...,
        relation: ConstraintRelation = ...,
        source: ConstraintTarget = ...,
        source_attribute: ConstraintAttribute = ...,
        strength: int = ...,
        target: ConstraintTarget = ...,
        target_attribute: ConstraintAttribute = ...,
    ) -> None: ...
    def get_constant(self) -> float: ...
    def get_multiplier(self) -> float: ...
    def get_relation(self) -> ConstraintRelation: ...
    def get_source(self) -> typing.Optional[ConstraintTarget]: ...
    def get_source_attribute(self) -> ConstraintAttribute: ...
    def get_strength(self) -> int: ...
    def get_target(self) -> typing.Optional[ConstraintTarget]: ...
    def get_target_attribute(self) -> ConstraintAttribute: ...
    def is_attached(self) -> bool: ...
    def is_constant(self) -> bool: ...
    def is_required(self) -> bool: ...
    @classmethod
    def new(
        cls,
        target: typing.Optional[ConstraintTarget],
        target_attribute: ConstraintAttribute,
        relation: ConstraintRelation,
        source: typing.Optional[ConstraintTarget],
        source_attribute: ConstraintAttribute,
        multiplier: float,
        constant: float,
        strength: int,
    ) -> Constraint: ...
    @classmethod
    def new_constant(
        cls,
        target: typing.Optional[ConstraintTarget],
        target_attribute: ConstraintAttribute,
        relation: ConstraintRelation,
        constant: float,
        strength: int,
    ) -> Constraint: ...

class ConstraintClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ConstraintClass()
    """

    parent_class: GObject.ObjectClass = ...

class ConstraintGuide(GObject.Object, ConstraintTarget):
    """
    :Constructors:

    ::

        ConstraintGuide(**properties)
        new() -> Gtk.ConstraintGuide

    Object GtkConstraintGuide

    Properties from GtkConstraintGuide:
      min-width -> gint: min-width
      min-height -> gint: min-height
      nat-width -> gint: nat-width
      nat-height -> gint: nat-height
      max-width -> gint: max-width
      max-height -> gint: max-height
      strength -> GtkConstraintStrength: strength
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        max_height: int
        max_width: int
        min_height: int
        min_width: int
        name: typing.Optional[str]
        nat_height: int
        nat_width: int
        strength: ConstraintStrength

    props: Props = ...
    def __init__(
        self,
        max_height: int = ...,
        max_width: int = ...,
        min_height: int = ...,
        min_width: int = ...,
        name: typing.Optional[str] = ...,
        nat_height: int = ...,
        nat_width: int = ...,
        strength: ConstraintStrength = ...,
    ) -> None: ...
    def get_max_size(self) -> typing.Tuple[int, int]: ...
    def get_min_size(self) -> typing.Tuple[int, int]: ...
    def get_name(self) -> typing.Optional[str]: ...
    def get_nat_size(self) -> typing.Tuple[int, int]: ...
    def get_strength(self) -> ConstraintStrength: ...
    @classmethod
    def new(cls) -> ConstraintGuide: ...
    def set_max_size(self, width: int, height: int) -> None: ...
    def set_min_size(self, width: int, height: int) -> None: ...
    def set_name(self, name: typing.Optional[str] = None) -> None: ...
    def set_nat_size(self, width: int, height: int) -> None: ...
    def set_strength(self, strength: ConstraintStrength) -> None: ...

class ConstraintGuideClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ConstraintGuideClass()
    """

    parent_class: GObject.ObjectClass = ...

class ConstraintLayout(LayoutManager, Buildable):
    """
    :Constructors:

    ::

        ConstraintLayout(**properties)
        new() -> Gtk.LayoutManager

    Object GtkConstraintLayout

    Signals from GObject:
      notify (GParam)
    """
    def add_constraint(self, constraint: Constraint) -> None: ...
    def add_constraints_from_description(
        self,
        lines: typing.Sequence[str],
        hspacing: int,
        vspacing: int,
        views: dict[str, ConstraintTarget],
    ) -> list[Constraint]: ...
    def add_guide(self, guide: ConstraintGuide) -> None: ...
    @classmethod
    def new(cls) -> ConstraintLayout: ...
    # override
    def observe_constraints(self) -> Gio.ListModel[typing.Any]: ...
    # override
    def observe_guides(self) -> Gio.ListModel[typing.Any]: ...
    def remove_all_constraints(self) -> None: ...
    def remove_constraint(self, constraint: Constraint) -> None: ...
    def remove_guide(self, guide: ConstraintGuide) -> None: ...

class ConstraintLayoutChild(LayoutChild):
    """
    :Constructors:

    ::

        ConstraintLayoutChild(**properties)

    Object GtkConstraintLayoutChild

    Properties from GtkLayoutChild:
      layout-manager -> GtkLayoutManager: layout-manager
      child-widget -> GtkWidget: child-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutChild.Props):
        child_widget: Widget
        layout_manager: LayoutManager

    props: Props = ...
    def __init__(
        self, child_widget: Widget = ..., layout_manager: LayoutManager = ...
    ) -> None: ...

class ConstraintLayoutChildClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ConstraintLayoutChildClass()
    """

    parent_class: LayoutChildClass = ...

class ConstraintLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ConstraintLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class ConstraintTarget(GObject.GInterface): ...
class ConstraintTargetInterface(GObject.GPointer): ...

class CssLocation(GObject.GPointer):
    """
    :Constructors:

    ::

        CssLocation()
    """

    bytes: int = ...
    chars: int = ...
    lines: int = ...
    line_bytes: int = ...
    line_chars: int = ...

class CssProvider(GObject.Object, StyleProvider):
    """
    :Constructors:

    ::

        CssProvider(**properties)
        new() -> Gtk.CssProvider

    Object GtkCssProvider

    Signals from GtkCssProvider:
      parsing-error (GtkCssSection, GError)

    Properties from GtkCssProvider:
      prefers-color-scheme -> GtkInterfaceColorScheme: prefers-color-scheme
      prefers-contrast -> GtkInterfaceContrast: prefers-contrast

    Signals from GtkStyleProvider:
      gtk-private-changed ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        prefers_color_scheme: InterfaceColorScheme
        prefers_contrast: InterfaceContrast

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(
        self,
        prefers_color_scheme: InterfaceColorScheme = ...,
        prefers_contrast: InterfaceContrast = ...,
    ) -> None: ...
    def load_from_bytes(self, data: GLib.Bytes) -> None: ...
    def load_from_data(
        self, text, length=-1
    ): ...  # FIXME: Override is missing typing annotation
    def load_from_file(self, file: Gio.File) -> None: ...
    def load_from_path(self, path: str) -> None: ...
    def load_from_resource(self, resource_path: str) -> None: ...
    def load_from_string(self, string: str) -> None: ...
    def load_named(self, name: str, variant: typing.Optional[str] = None) -> None: ...
    @classmethod
    def new(cls) -> CssProvider: ...
    def to_string(self) -> str: ...

class CssProviderClass(GObject.GPointer): ...
class CssProviderPrivate(GObject.GPointer): ...

class CssSection(GObject.GBoxed):
    """
    :Constructors:

    ::

        new(file:Gio.File=None, start:Gtk.CssLocation, end:Gtk.CssLocation) -> Gtk.CssSection
        new_with_bytes(file:Gio.File=None, bytes:GLib.Bytes=None, start:Gtk.CssLocation, end:Gtk.CssLocation) -> Gtk.CssSection
    """
    def get_bytes(self) -> typing.Optional[GLib.Bytes]: ...
    def get_end_location(self) -> CssLocation: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_parent(self) -> typing.Optional[CssSection]: ...
    def get_start_location(self) -> CssLocation: ...
    @classmethod
    def new(
        cls, file: typing.Optional[Gio.File], start: CssLocation, end: CssLocation
    ) -> CssSection: ...
    @classmethod
    def new_with_bytes(
        cls,
        file: typing.Optional[Gio.File],
        bytes: typing.Optional[GLib.Bytes],
        start: CssLocation,
        end: CssLocation,
    ) -> CssSection: ...
    def print_(self, string: GLib.String) -> None: ...
    def ref(self) -> CssSection: ...
    def to_string(self) -> str: ...
    def unref(self) -> None: ...

class CssStyleChange(GObject.GPointer): ...

class CustomFilter(Filter):
    """
    :Constructors:

    ::

        CustomFilter(**properties)
        new(match_func:Gtk.CustomFilterFunc=None, user_data=None) -> Gtk.CustomFilter

    Object GtkCustomFilter

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(
        cls,
        match_func: typing.Optional[typing.Callable[..., bool]] = None,
        *user_data: typing.Any,
    ) -> CustomFilter: ...
    def set_filter_func(
        self,
        match_func: typing.Optional[typing.Callable[..., bool]] = None,
        *user_data: typing.Any,
    ) -> None: ...

class CustomFilterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CustomFilterClass()
    """

    parent_class: FilterClass = ...

class CustomLayout(LayoutManager):
    """
    :Constructors:

    ::

        CustomLayout(**properties)
        new(request_mode:Gtk.CustomRequestModeFunc=None, measure:Gtk.CustomMeasureFunc, allocate:Gtk.CustomAllocateFunc) -> Gtk.LayoutManager

    Object GtkCustomLayout

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(
        cls,
        request_mode: typing.Optional[typing.Callable[[Widget], SizeRequestMode]],
        measure: typing.Callable[
            [Widget, Orientation, int], typing.Tuple[int, int, int, int]
        ],
        allocate: typing.Callable[[Widget, int, int, int], None],
    ) -> CustomLayout: ...

class CustomLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CustomLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class CustomSorter(Sorter):
    """
    :Constructors:

    ::

        CustomSorter(**properties)
        new(sort_func:GLib.CompareDataFunc=None, user_data=None) -> Gtk.CustomSorter

    Object GtkCustomSorter

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """
    # override
    @classmethod
    def new(
        cls,
        sort_func: typing.Optional[
            typing.Callable[[typing.Any, typing.Any, typing.Any], int]
        ] = None,
        user_data: typing.Any = None,
    ) -> CustomSorter: ...
    # override
    def set_sort_func(
        self,
        sort_func: typing.Optional[
            typing.Callable[[typing.Any, typing.Any, typing.Any], int]
        ] = None,
        user_data: typing.Any = None,
    ) -> None: ...

class CustomSorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CustomSorterClass()
    """

    parent_class: SorterClass = ...

class Dialog(
    Window, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        Dialog(**properties)
        new() -> Gtk.Widget

    Object GtkDialog

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Window.Props):
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    parent_instance: Window = ...
    def __init__(
        self,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_action_widget(self, child: Widget, response_id: int) -> None: ...
    def add_button(self, button_text: str, response_id: int) -> Widget: ...
    def add_buttons(self, *args):
        """
        The add_buttons() method adds several buttons to the Gtk.Dialog using
        the button data passed as arguments to the method. This method is the
        same as calling the Gtk.Dialog.add_button() repeatedly. The button data
        pairs - button text (or stock ID) and a response ID integer are passed
        individually. For example:

        .. code-block:: python

            dialog.add_buttons(Gtk.STOCK_OPEN, 42, "Close", Gtk.ResponseType.CLOSE)

        will add "Open" and "Close" buttons to dialog.
        """  # FIXME: Override is missing typing annotation
    def do_close(self) -> None: ...
    def do_response(self, response_id: int) -> None: ...
    def get_content_area(self) -> Box: ...
    def get_header_bar(self) -> HeaderBar: ...
    def get_response_for_widget(self, widget: Widget) -> int: ...
    def get_widget_for_response(self, response_id: int) -> typing.Optional[Widget]: ...
    @classmethod
    def new(cls) -> Dialog: ...
    def response(self, response_id: int) -> None: ...
    def set_default_response(self, response_id: int) -> None: ...
    def set_response_sensitive(self, response_id: int, setting: bool) -> None: ...

class DialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DialogClass()
    """

    parent_class: WindowClass = ...
    response: typing.Callable[[Dialog, int], None] = ...
    close: typing.Callable[[Dialog], None] = ...
    padding: list[None] = ...

# override
class DirectoryList(GObject.Object, Gio.ListModel[typing.Any]):
    """
    :Constructors:

    ::

        DirectoryList(**properties)
        new(attributes:str=None, file:Gio.File=None) -> Gtk.DirectoryList

    Object GtkDirectoryList

    Properties from GtkDirectoryList:
      attributes -> gchararray: attributes
      error -> GError: error
      file -> GFile: file
      io-priority -> gint: io-priority
      item-type -> GType: item-type
      loading -> gboolean: loading
      monitored -> gboolean: monitored
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        attributes: typing.Optional[str]
        error: typing.Optional[GLib.Error]
        file: typing.Optional[Gio.File]
        io_priority: int
        item_type: typing.Type[typing.Any]
        loading: bool
        monitored: bool
        n_items: int

    props: Props = ...
    def __init__(
        self,
        attributes: typing.Optional[str] = ...,
        file: typing.Optional[Gio.File] = ...,
        io_priority: int = ...,
        monitored: bool = ...,
    ) -> None: ...
    def get_attributes(self) -> typing.Optional[str]: ...
    def get_error(self) -> typing.Optional[GLib.Error]: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_io_priority(self) -> int: ...
    def get_monitored(self) -> bool: ...
    def is_loading(self) -> bool: ...
    @classmethod
    def new(
        cls,
        attributes: typing.Optional[str] = None,
        file: typing.Optional[Gio.File] = None,
    ) -> DirectoryList: ...
    def set_attributes(self, attributes: typing.Optional[str] = None) -> None: ...
    def set_file(self, file: typing.Optional[Gio.File] = None) -> None: ...
    def set_io_priority(self, io_priority: int) -> None: ...
    def set_monitored(self, monitored: bool) -> None: ...

class DirectoryListClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DirectoryListClass()
    """

    parent_class: GObject.ObjectClass = ...

class DragIcon(Widget, Accessible, Buildable, ConstraintTarget, Native, Root):
    """
    :Constructors:

    ::

        DragIcon(**properties)
        get_for_drag(drag:Gdk.Drag) -> Gtk.Widget

    Object GtkDragIcon

    Properties from GtkDragIcon:
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    @staticmethod
    def create_widget_for_value(value: typing.Any) -> typing.Optional[Widget]: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    @classmethod
    def get_for_drag(cls, drag: Gdk.Drag) -> DragIcon: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    @staticmethod
    def set_from_paintable(
        drag: Gdk.Drag, paintable: Gdk.Paintable, hot_x: int, hot_y: int
    ) -> None: ...

class DragIconClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DragIconClass()
    """

    parent_class: WidgetClass = ...

class DragSource(GestureSingle):
    """
    :Constructors:

    ::

        DragSource(**properties)
        new() -> Gtk.DragSource

    Object GtkDragSource

    Signals from GtkDragSource:
      prepare (gdouble, gdouble) -> GdkContentProvider
      drag-begin (GdkDrag)
      drag-end (GdkDrag, gboolean)
      drag-cancel (GdkDrag, GdkDragCancelReason) -> gboolean

    Properties from GtkDragSource:
      content -> GdkContentProvider: content
      actions -> GdkDragAction: actions

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureSingle.Props):
        actions: Gdk.DragAction
        content: typing.Optional[Gdk.ContentProvider]
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        actions: Gdk.DragAction = ...,
        content: typing.Optional[Gdk.ContentProvider] = ...,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def drag_cancel(self) -> None: ...
    def get_actions(self) -> Gdk.DragAction: ...
    def get_content(self) -> typing.Optional[Gdk.ContentProvider]: ...
    def get_drag(self) -> typing.Optional[Gdk.Drag]: ...
    @classmethod
    def new(cls) -> DragSource: ...
    def set_actions(self, actions: Gdk.DragAction) -> None: ...
    def set_content(
        self, content: typing.Optional[Gdk.ContentProvider] = None
    ) -> None: ...
    def set_icon(
        self, paintable: typing.Optional[Gdk.Paintable], hot_x: int, hot_y: int
    ) -> None: ...

class DragSourceClass(GObject.GPointer): ...

class DrawingArea(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        DrawingArea(**properties)
        new() -> Gtk.Widget

    Object GtkDrawingArea

    Signals from GtkDrawingArea:
      resize (gint, gint)

    Properties from GtkDrawingArea:
      content-width -> gint: content-width
      content-height -> gint: content-height

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        content_height: int
        content_width: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    widget: Widget = ...
    def __init__(
        self,
        content_height: int = ...,
        content_width: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def do_resize(self, width: int, height: int) -> None: ...
    def get_content_height(self) -> int: ...
    def get_content_width(self) -> int: ...
    @classmethod
    def new(cls) -> DrawingArea: ...
    def set_content_height(self, height: int) -> None: ...
    def set_content_width(self, width: int) -> None: ...
    def set_draw_func(
        self,
        draw_func: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...

class DrawingAreaClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DrawingAreaClass()
    """

    parent_class: WidgetClass = ...
    resize: typing.Callable[[DrawingArea, int, int], None] = ...
    padding: list[None] = ...

class DropControllerMotion(EventController):
    """
    :Constructors:

    ::

        DropControllerMotion(**properties)
        new() -> Gtk.EventController

    Object GtkDropControllerMotion

    Signals from GtkDropControllerMotion:
      enter (gdouble, gdouble)
      leave ()
      motion (gdouble, gdouble)

    Properties from GtkDropControllerMotion:
      contains-pointer -> gboolean: contains-pointer
      drop -> GdkDrop: drop
      is-pointer -> gboolean: is-pointer

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        contains_pointer: bool
        drop: typing.Optional[Gdk.Drop]
        is_pointer: bool
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def contains_pointer(self) -> bool: ...
    def get_drop(self) -> typing.Optional[Gdk.Drop]: ...
    def is_pointer(self) -> bool: ...
    @classmethod
    def new(cls) -> DropControllerMotion: ...

class DropControllerMotionClass(GObject.GPointer): ...

class DropDown(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        DropDown(**properties)
        new(model:Gio.ListModel=None, expression:Gtk.Expression=None) -> Gtk.Widget
        new_from_strings(strings:list) -> Gtk.Widget

    Object GtkDropDown

    Signals from GtkDropDown:
      activate ()

    Properties from GtkDropDown:
      factory -> GtkListItemFactory: factory
      header-factory -> GtkListItemFactory: header-factory
      list-factory -> GtkListItemFactory: list-factory
      model -> GListModel: model
      selected -> guint: selected
      selected-item -> GObject: selected-item
      enable-search -> gboolean: enable-search
      expression -> GtkExpression: expression
      show-arrow -> gboolean: show-arrow
      search-match-mode -> GtkStringFilterMatchMode: search-match-mode

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(Widget.Props):
        enable_search: bool
        expression: typing.Optional[Expression]
        factory: typing.Optional[ListItemFactory]
        header_factory: typing.Optional[ListItemFactory]
        list_factory: typing.Optional[ListItemFactory]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        search_match_mode: StringFilterMatchMode
        selected: int
        selected_item: typing.Optional[GObject.Object]
        show_arrow: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    # override
    def __init__(
        self,
        enable_search: bool = ...,
        expression: typing.Optional[Expression] = ...,
        factory: typing.Optional[ListItemFactory] = ...,
        header_factory: typing.Optional[ListItemFactory] = ...,
        list_factory: typing.Optional[ListItemFactory] = ...,
        model: typing.Optional[Gio.ListModel[typing.Any]] = ...,
        search_match_mode: StringFilterMatchMode = ...,
        selected: int = ...,
        show_arrow: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_enable_search(self) -> bool: ...
    def get_expression(self) -> typing.Optional[Expression]: ...
    def get_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_header_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_list_factory(self) -> typing.Optional[ListItemFactory]: ...
    # override
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_search_match_mode(self) -> StringFilterMatchMode: ...
    def get_selected(self) -> int: ...
    def get_selected_item(self) -> typing.Optional[GObject.Object]: ...
    def get_show_arrow(self) -> bool: ...
    # override
    @classmethod
    def new(
        cls,
        model: typing.Optional[Gio.ListModel[typing.Any]] = None,
        expression: typing.Optional[Expression] = None,
    ) -> DropDown: ...
    @classmethod
    def new_from_strings(cls, strings: typing.Sequence[str]) -> DropDown: ...
    def set_enable_search(self, enable_search: bool) -> None: ...
    def set_expression(
        self, expression: typing.Optional[Expression] = None
    ) -> None: ...
    def set_factory(self, factory: typing.Optional[ListItemFactory] = None) -> None: ...
    def set_header_factory(
        self, factory: typing.Optional[ListItemFactory] = None
    ) -> None: ...
    def set_list_factory(
        self, factory: typing.Optional[ListItemFactory] = None
    ) -> None: ...
    # override
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...
    def set_search_match_mode(
        self, search_match_mode: StringFilterMatchMode
    ) -> None: ...
    def set_selected(self, position: int) -> None: ...
    def set_show_arrow(self, show_arrow: bool) -> None: ...

class DropDownClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DropDownClass()
    """

    parent_class: WidgetClass = ...

class DropTarget(EventController):
    """
    :Constructors:

    ::

        DropTarget(**properties)
        new(type:GType, actions:Gdk.DragAction) -> Gtk.DropTarget

    Object GtkDropTarget

    Signals from GtkDropTarget:
      drop (GValue, gdouble, gdouble) -> gboolean
      enter (gdouble, gdouble) -> GdkDragAction
      leave ()
      motion (gdouble, gdouble) -> GdkDragAction
      accept (GdkDrop) -> gboolean

    Properties from GtkDropTarget:
      actions -> GdkDragAction: actions
      current-drop -> GdkDrop: current-drop
      drop -> GdkDrop: drop
      formats -> GdkContentFormats: formats
      preload -> gboolean: preload
      value -> GValue: value

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        actions: Gdk.DragAction
        current_drop: typing.Optional[Gdk.Drop]
        drop: typing.Optional[Gdk.Drop]
        formats: typing.Optional[Gdk.ContentFormats]
        preload: bool
        value: typing.Optional[typing.Any]
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        actions: Gdk.DragAction = ...,
        formats: Gdk.ContentFormats = ...,
        preload: bool = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_actions(self) -> Gdk.DragAction: ...
    def get_current_drop(self) -> typing.Optional[Gdk.Drop]: ...
    def get_drop(self) -> typing.Optional[Gdk.Drop]: ...
    def get_formats(self) -> typing.Optional[Gdk.ContentFormats]: ...
    def get_gtypes(self) -> typing.Optional[list[typing.Type[typing.Any]]]: ...
    def get_preload(self) -> bool: ...
    def get_value(self) -> typing.Optional[typing.Any]: ...
    # override
    @classmethod
    def new(
        cls, type: typing.Type[typing.Any], actions: Gdk.DragAction
    ) -> DropTarget: ...
    def reject(self) -> None: ...
    def set_actions(self, actions: Gdk.DragAction) -> None: ...
    def set_gtypes(
        self, types: typing.Optional[typing.Sequence[typing.Type[typing.Any]]] = None
    ) -> None: ...
    def set_preload(self, preload: bool) -> None: ...

class DropTargetAsync(EventController):
    """
    :Constructors:

    ::

        DropTargetAsync(**properties)
        new(formats:Gdk.ContentFormats=None, actions:Gdk.DragAction) -> Gtk.DropTargetAsync

    Object GtkDropTargetAsync

    Signals from GtkDropTargetAsync:
      drop (GdkDrop, gdouble, gdouble) -> gboolean
      accept (GdkDrop) -> gboolean
      drag-enter (GdkDrop, gdouble, gdouble) -> GdkDragAction
      drag-motion (GdkDrop, gdouble, gdouble) -> GdkDragAction
      drag-leave (GdkDrop)

    Properties from GtkDropTargetAsync:
      actions -> GdkDragAction: actions
      formats -> GdkContentFormats: formats

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        actions: Gdk.DragAction
        formats: typing.Optional[Gdk.ContentFormats]
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        actions: Gdk.DragAction = ...,
        formats: typing.Optional[Gdk.ContentFormats] = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_actions(self) -> Gdk.DragAction: ...
    def get_formats(self) -> typing.Optional[Gdk.ContentFormats]: ...
    @classmethod
    def new(
        cls, formats: typing.Optional[Gdk.ContentFormats], actions: Gdk.DragAction
    ) -> DropTargetAsync: ...
    def reject_drop(self, drop: Gdk.Drop) -> None: ...
    def set_actions(self, actions: Gdk.DragAction) -> None: ...
    def set_formats(
        self, formats: typing.Optional[Gdk.ContentFormats] = None
    ) -> None: ...

class DropTargetAsyncClass(GObject.GPointer): ...
class DropTargetClass(GObject.GPointer): ...

class Editable(GObject.GInterface):
    """
    Interface GtkEditable

    Signals from GObject:
      notify (GParam)
    """
    def delegate_get_accessible_platform_state(
        self, state: AccessiblePlatformState
    ) -> bool: ...
    @staticmethod
    def delegate_get_property(
        object: GObject.Object,
        prop_id: int,
        value: typing.Any,
        pspec: GObject.ParamSpec,
    ) -> bool: ...
    @staticmethod
    def delegate_set_property(
        object: GObject.Object,
        prop_id: int,
        value: typing.Any,
        pspec: GObject.ParamSpec,
    ) -> bool: ...
    def delete_selection(self) -> None: ...
    def delete_text(self, start_pos: int, end_pos: int) -> None: ...
    def finish_delegate(self) -> None: ...
    def get_alignment(self) -> float: ...
    def get_chars(self, start_pos: int, end_pos: int) -> str: ...
    def get_delegate(self) -> typing.Optional[Editable]: ...
    def get_editable(self) -> bool: ...
    def get_enable_undo(self) -> bool: ...
    def get_max_width_chars(self) -> int: ...
    def get_position(self) -> int: ...
    def get_selection_bounds(
        self,
    ) -> typing.Tuple[int, int] | typing.Tuple[()]: ...  # CHECK Wrapped function
    def get_text(self) -> str: ...
    def get_width_chars(self) -> int: ...
    def init_delegate(self) -> None: ...
    def insert_text(
        self, text, position
    ): ...  # FIXME: Override is missing typing annotation
    @staticmethod
    def install_properties(
        object_class: GObject.ObjectClass, first_prop: int
    ) -> int: ...
    def select_region(self, start_pos: int, end_pos: int) -> None: ...
    def set_alignment(self, xalign: float) -> None: ...
    def set_editable(self, is_editable: bool) -> None: ...
    def set_enable_undo(self, enable_undo: bool) -> None: ...
    def set_max_width_chars(self, n_chars: int) -> None: ...
    def set_position(self, position: int) -> None: ...
    def set_text(self, text: str) -> None: ...
    def set_width_chars(self, n_chars: int) -> None: ...

class EditableInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        EditableInterface()
    """

    base_iface: GObject.TypeInterface = ...
    insert_text: typing.Callable[[Editable, str, int], int] = ...
    delete_text: typing.Callable[[Editable, int, int], None] = ...
    changed: typing.Callable[[Editable], None] = ...
    get_text: typing.Callable[[Editable], str] = ...
    do_insert_text: typing.Callable[[Editable, str, int], int] = ...
    do_delete_text: typing.Callable[[Editable, int, int], None] = ...
    get_selection_bounds: typing.Callable[
        [Editable], typing.Tuple[bool, int, int]
    ] = ...
    set_selection_bounds: typing.Callable[[Editable, int, int], None] = ...
    get_delegate: typing.Callable[[Editable], typing.Optional[Editable]] = ...

class EditableLabel(Widget, Accessible, Buildable, ConstraintTarget, Editable):
    """
    :Constructors:

    ::

        EditableLabel(**properties)
        new(str:str) -> Gtk.Widget

    Object GtkEditableLabel

    Properties from GtkEditableLabel:
      editing -> gboolean: editing

    Signals from GtkEditable:
      changed ()
      insert-text (gchararray, gint, gpointer)
      delete-text (gint, gint)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        editing: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        cursor_position: int
        editable: bool
        enable_undo: bool
        max_width_chars: int
        selection_bound: int
        text: str
        width_chars: int
        xalign: float

    props: Props = ...
    def __init__(
        self,
        editing: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editable: bool = ...,
        enable_undo: bool = ...,
        max_width_chars: int = ...,
        text: str = ...,
        width_chars: int = ...,
        xalign: float = ...,
    ) -> None: ...
    def get_editing(self) -> bool: ...
    @classmethod
    def new(cls, str: str) -> EditableLabel: ...
    def start_editing(self) -> None: ...
    def stop_editing(self, commit: bool) -> None: ...

class EditableLabelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        EditableLabelClass()
    """

    parent_class: WidgetClass = ...

class EmojiChooser(
    Popover, Accessible, Buildable, ConstraintTarget, Native, ShortcutManager
):
    """
    :Constructors:

    ::

        EmojiChooser(**properties)
        new() -> Gtk.Widget

    Object GtkEmojiChooser

    Signals from GtkEmojiChooser:
      emoji-picked (gchararray)

    Signals from GtkPopover:
      closed ()
      activate-default ()

    Properties from GtkPopover:
      pointing-to -> GdkRectangle: pointing-to
      position -> GtkPositionType: position
      autohide -> gboolean: autohide
      default-widget -> GtkWidget: default-widget
      has-arrow -> gboolean: has-arrow
      mnemonics-visible -> gboolean: mnemonics-visible
      child -> GtkWidget: child
      cascade-popdown -> gboolean: cascade-popdown

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Popover.Props):
        autohide: bool
        cascade_popdown: bool
        child: typing.Optional[Widget]
        default_widget: typing.Optional[Widget]
        has_arrow: bool
        mnemonics_visible: bool
        pointing_to: Gdk.Rectangle
        position: PositionType
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        autohide: bool = ...,
        cascade_popdown: bool = ...,
        child: typing.Optional[Widget] = ...,
        default_widget: typing.Optional[Widget] = ...,
        has_arrow: bool = ...,
        mnemonics_visible: bool = ...,
        pointing_to: typing.Optional[Gdk.Rectangle] = ...,
        position: PositionType = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> EmojiChooser: ...

class EmojiChooserClass(GObject.GPointer): ...

class Entry(Widget, Accessible, Buildable, CellEditable, ConstraintTarget, Editable):
    """
    :Constructors:

    ::

        Entry(**properties)
        new() -> Gtk.Widget
        new_with_buffer(buffer:Gtk.EntryBuffer) -> Gtk.Widget

    Object GtkEntry

    Signals from GtkEntry:
      activate ()
      icon-press (GtkEntryIconPosition)
      icon-release (GtkEntryIconPosition)

    Properties from GtkEntry:
      buffer -> GtkEntryBuffer: buffer
      max-length -> gint: max-length
      visibility -> gboolean: visibility
      has-frame -> gboolean: has-frame
      invisible-char -> guint: invisible-char
      activates-default -> gboolean: activates-default
      scroll-offset -> gint: scroll-offset
      truncate-multiline -> gboolean: truncate-multiline
      overwrite-mode -> gboolean: overwrite-mode
      text-length -> guint: text-length
      invisible-char-set -> gboolean: invisible-char-set
      progress-fraction -> gdouble: progress-fraction
      progress-pulse-step -> gdouble: progress-pulse-step
      primary-icon-paintable -> GdkPaintable: primary-icon-paintable
      secondary-icon-paintable -> GdkPaintable: secondary-icon-paintable
      primary-icon-name -> gchararray: primary-icon-name
      secondary-icon-name -> gchararray: secondary-icon-name
      primary-icon-gicon -> GIcon: primary-icon-gicon
      secondary-icon-gicon -> GIcon: secondary-icon-gicon
      primary-icon-storage-type -> GtkImageType: primary-icon-storage-type
      secondary-icon-storage-type -> GtkImageType: secondary-icon-storage-type
      primary-icon-activatable -> gboolean: primary-icon-activatable
      secondary-icon-activatable -> gboolean: secondary-icon-activatable
      primary-icon-sensitive -> gboolean: primary-icon-sensitive
      secondary-icon-sensitive -> gboolean: secondary-icon-sensitive
      primary-icon-tooltip-text -> gchararray: primary-icon-tooltip-text
      secondary-icon-tooltip-text -> gchararray: secondary-icon-tooltip-text
      primary-icon-tooltip-markup -> gchararray: primary-icon-tooltip-markup
      secondary-icon-tooltip-markup -> gchararray: secondary-icon-tooltip-markup
      im-module -> gchararray: im-module
      placeholder-text -> gchararray: placeholder-text
      completion -> GtkEntryCompletion: completion
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints
      attributes -> PangoAttrList: attributes
      tabs -> PangoTabArray: tabs
      extra-menu -> GMenuModel: extra-menu
      show-emoji-icon -> gboolean: show-emoji-icon
      enable-emoji-completion -> gboolean: enable-emoji-completion
      menu-entry-icon-primary-text -> gchararray: menu-entry-icon-primary-text
      menu-entry-icon-secondary-text -> gchararray: menu-entry-icon-secondary-text

    Signals from GtkEditable:
      changed ()
      insert-text (gchararray, gint, gpointer)
      delete-text (gint, gint)

    Signals from GtkCellEditable:
      editing-done ()
      remove-widget ()

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activates_default: bool
        attributes: typing.Optional[Pango.AttrList]
        buffer: EntryBuffer
        completion: typing.Optional[EntryCompletion]
        enable_emoji_completion: bool
        extra_menu: typing.Optional[Gio.MenuModel]
        has_frame: bool
        im_module: str
        input_hints: InputHints
        input_purpose: InputPurpose
        invisible_char: int
        invisible_char_set: bool
        max_length: int
        menu_entry_icon_primary_text: str
        menu_entry_icon_secondary_text: str
        overwrite_mode: bool
        placeholder_text: typing.Optional[str]
        primary_icon_activatable: bool
        primary_icon_gicon: Gio.Icon
        primary_icon_name: str
        primary_icon_paintable: Gdk.Paintable
        primary_icon_sensitive: bool
        primary_icon_storage_type: ImageType
        primary_icon_tooltip_markup: str
        primary_icon_tooltip_text: str
        progress_fraction: float
        progress_pulse_step: float
        scroll_offset: int
        secondary_icon_activatable: bool
        secondary_icon_gicon: Gio.Icon
        secondary_icon_name: str
        secondary_icon_paintable: Gdk.Paintable
        secondary_icon_sensitive: bool
        secondary_icon_storage_type: ImageType
        secondary_icon_tooltip_markup: str
        secondary_icon_tooltip_text: str
        show_emoji_icon: bool
        tabs: typing.Optional[Pango.TabArray]
        text_length: int
        truncate_multiline: bool
        visibility: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        editing_canceled: bool
        cursor_position: int
        editable: bool
        enable_undo: bool
        max_width_chars: int
        selection_bound: int
        text: str
        width_chars: int
        xalign: float

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        activates_default: bool = ...,
        attributes: Pango.AttrList = ...,
        buffer: EntryBuffer = ...,
        completion: typing.Optional[EntryCompletion] = ...,
        enable_emoji_completion: bool = ...,
        extra_menu: typing.Optional[Gio.MenuModel] = ...,
        has_frame: bool = ...,
        im_module: str = ...,
        input_hints: InputHints = ...,
        input_purpose: InputPurpose = ...,
        invisible_char: int = ...,
        invisible_char_set: bool = ...,
        max_length: int = ...,
        menu_entry_icon_primary_text: str = ...,
        menu_entry_icon_secondary_text: str = ...,
        overwrite_mode: bool = ...,
        placeholder_text: typing.Optional[str] = ...,
        primary_icon_activatable: bool = ...,
        primary_icon_gicon: Gio.Icon = ...,
        primary_icon_name: str = ...,
        primary_icon_paintable: Gdk.Paintable = ...,
        primary_icon_sensitive: bool = ...,
        primary_icon_tooltip_markup: str = ...,
        primary_icon_tooltip_text: str = ...,
        progress_fraction: float = ...,
        progress_pulse_step: float = ...,
        secondary_icon_activatable: bool = ...,
        secondary_icon_gicon: Gio.Icon = ...,
        secondary_icon_name: str = ...,
        secondary_icon_paintable: Gdk.Paintable = ...,
        secondary_icon_sensitive: bool = ...,
        secondary_icon_tooltip_markup: str = ...,
        secondary_icon_tooltip_text: str = ...,
        show_emoji_icon: bool = ...,
        tabs: typing.Optional[Pango.TabArray] = ...,
        truncate_multiline: bool = ...,
        visibility: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editing_canceled: bool = ...,
        editable: bool = ...,
        enable_undo: bool = ...,
        max_width_chars: int = ...,
        text: str = ...,
        width_chars: int = ...,
        xalign: float = ...,
    ) -> None: ...
    def do_activate(self) -> None: ...
    def get_activates_default(self) -> bool: ...
    def get_alignment(self) -> float: ...
    def get_attributes(self) -> typing.Optional[Pango.AttrList]: ...
    def get_buffer(self) -> EntryBuffer: ...
    def get_completion(self) -> typing.Optional[EntryCompletion]: ...
    def get_current_icon_drag_source(self) -> int: ...
    def get_extra_menu(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_has_frame(self) -> bool: ...
    def get_icon_activatable(self, icon_pos: EntryIconPosition) -> bool: ...
    def get_icon_area(self, icon_pos: EntryIconPosition) -> Gdk.Rectangle: ...
    def get_icon_at_pos(self, x: int, y: int) -> int: ...
    def get_icon_gicon(
        self, icon_pos: EntryIconPosition
    ) -> typing.Optional[Gio.Icon]: ...
    def get_icon_name(self, icon_pos: EntryIconPosition) -> typing.Optional[str]: ...
    def get_icon_paintable(
        self, icon_pos: EntryIconPosition
    ) -> typing.Optional[Gdk.Paintable]: ...
    def get_icon_sensitive(self, icon_pos: EntryIconPosition) -> bool: ...
    def get_icon_storage_type(self, icon_pos: EntryIconPosition) -> ImageType: ...
    def get_icon_tooltip_markup(
        self, icon_pos: EntryIconPosition
    ) -> typing.Optional[str]: ...
    def get_icon_tooltip_text(
        self, icon_pos: EntryIconPosition
    ) -> typing.Optional[str]: ...
    def get_input_hints(self) -> InputHints: ...
    def get_input_purpose(self) -> InputPurpose: ...
    def get_invisible_char(self) -> str: ...
    def get_max_length(self) -> int: ...
    def get_menu_entry_icon_text(
        self, icon_pos: EntryIconPosition
    ) -> typing.Optional[str]: ...
    def get_overwrite_mode(self) -> bool: ...
    def get_placeholder_text(self) -> typing.Optional[str]: ...
    def get_progress_fraction(self) -> float: ...
    def get_progress_pulse_step(self) -> float: ...
    def get_tabs(self) -> typing.Optional[Pango.TabArray]: ...
    def get_text_length(self) -> int: ...
    def get_visibility(self) -> bool: ...
    def grab_focus_without_selecting(self) -> bool: ...
    @classmethod
    def new(cls) -> Entry: ...
    @classmethod
    def new_with_buffer(cls, buffer: EntryBuffer) -> Entry: ...
    def progress_pulse(self) -> None: ...
    def reset_im_context(self) -> None: ...
    def set_activates_default(self, setting: bool) -> None: ...
    def set_alignment(self, xalign: float) -> None: ...
    def set_attributes(self, attrs: Pango.AttrList) -> None: ...
    def set_buffer(self, buffer: EntryBuffer) -> None: ...
    def set_completion(
        self, completion: typing.Optional[EntryCompletion] = None
    ) -> None: ...
    def set_extra_menu(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def set_has_frame(self, setting: bool) -> None: ...
    def set_icon_activatable(
        self, icon_pos: EntryIconPosition, activatable: bool
    ) -> None: ...
    def set_icon_drag_source(
        self,
        icon_pos: EntryIconPosition,
        provider: Gdk.ContentProvider,
        actions: Gdk.DragAction,
    ) -> None: ...
    def set_icon_from_gicon(
        self, icon_pos: EntryIconPosition, icon: typing.Optional[Gio.Icon] = None
    ) -> None: ...
    def set_icon_from_icon_name(
        self, icon_pos: EntryIconPosition, icon_name: typing.Optional[str] = None
    ) -> None: ...
    def set_icon_from_paintable(
        self,
        icon_pos: EntryIconPosition,
        paintable: typing.Optional[Gdk.Paintable] = None,
    ) -> None: ...
    def set_icon_sensitive(
        self, icon_pos: EntryIconPosition, sensitive: bool
    ) -> None: ...
    def set_icon_tooltip_markup(
        self, icon_pos: EntryIconPosition, tooltip: typing.Optional[str] = None
    ) -> None: ...
    def set_icon_tooltip_text(
        self, icon_pos: EntryIconPosition, tooltip: typing.Optional[str] = None
    ) -> None: ...
    def set_input_hints(self, hints: InputHints) -> None: ...
    def set_input_purpose(self, purpose: InputPurpose) -> None: ...
    def set_invisible_char(self, ch: str) -> None: ...
    def set_max_length(self, max: int) -> None: ...
    def set_menu_entry_icon_text(
        self, icon_pos: EntryIconPosition, text: str
    ) -> None: ...
    def set_overwrite_mode(self, overwrite: bool) -> None: ...
    def set_placeholder_text(self, text: typing.Optional[str] = None) -> None: ...
    def set_progress_fraction(self, fraction: float) -> None: ...
    def set_progress_pulse_step(self, fraction: float) -> None: ...
    def set_tabs(self, tabs: typing.Optional[Pango.TabArray] = None) -> None: ...
    def set_visibility(self, visible: bool) -> None: ...
    def unset_invisible_char(self) -> None: ...

class EntryBuffer(GObject.Object):
    """
    :Constructors:

    ::

        EntryBuffer(**properties)
        new(initial_chars:str=None, n_initial_chars:int) -> Gtk.EntryBuffer

    Object GtkEntryBuffer

    Signals from GtkEntryBuffer:
      inserted-text (guint, gchararray, guint)
      deleted-text (guint, guint)

    Properties from GtkEntryBuffer:
      text -> gchararray: text
      length -> guint: length
      max-length -> gint: max-length

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        length: int
        max_length: int
        text: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(self, max_length: int = ..., text: str = ...) -> None: ...
    def delete_text(self, position: int, n_chars: int) -> int: ...
    def do_delete_text(self, position: int, n_chars: int) -> int: ...
    def do_deleted_text(self, position: int, n_chars: int) -> None: ...
    def do_get_length(self) -> int: ...
    def do_get_text(self, n_bytes: int) -> str: ...
    def do_insert_text(self, position: int, chars: str, n_chars: int) -> int: ...
    def do_inserted_text(self, position: int, chars: str, n_chars: int) -> None: ...
    def emit_deleted_text(self, position: int, n_chars: int) -> None: ...
    def emit_inserted_text(self, position: int, chars: str, n_chars: int) -> None: ...
    def get_bytes(self) -> int: ...
    def get_length(self) -> int: ...
    def get_max_length(self) -> int: ...
    def get_text(self) -> str: ...
    def insert_text(self, position: int, chars: str, n_chars: int) -> int: ...
    @classmethod
    def new(
        cls, initial_chars: typing.Optional[str], n_initial_chars: int
    ) -> EntryBuffer: ...
    def set_max_length(self, max_length: int) -> None: ...
    def set_text(self, chars: str, n_chars: int) -> None: ...

class EntryBufferClass(GObject.GPointer):
    """
    :Constructors:

    ::

        EntryBufferClass()
    """

    parent_class: GObject.ObjectClass = ...
    inserted_text: typing.Callable[[EntryBuffer, int, str, int], None] = ...
    deleted_text: typing.Callable[[EntryBuffer, int, int], None] = ...
    get_text: typing.Callable[[EntryBuffer, int], str] = ...
    get_length: typing.Callable[[EntryBuffer], int] = ...
    insert_text: typing.Callable[[EntryBuffer, int, str, int], int] = ...
    delete_text: typing.Callable[[EntryBuffer, int, int], int] = ...

class EntryClass(GObject.GPointer):
    """
    :Constructors:

    ::

        EntryClass()
    """

    parent_class: WidgetClass = ...
    activate: typing.Callable[[Entry], None] = ...
    padding: list[None] = ...

class EntryCompletion(GObject.Object, Buildable, CellLayout):
    """
    :Constructors:

    ::

        EntryCompletion(**properties)
        new() -> Gtk.EntryCompletion
        new_with_area(area:Gtk.CellArea) -> Gtk.EntryCompletion

    Object GtkEntryCompletion

    Signals from GtkEntryCompletion:
      insert-prefix (gchararray) -> gboolean
      match-selected (GtkTreeModel, GtkTreeIter) -> gboolean
      cursor-on-match (GtkTreeModel, GtkTreeIter) -> gboolean
      no-matches ()

    Properties from GtkEntryCompletion:
      model -> GtkTreeModel: model
      minimum-key-length -> gint: minimum-key-length
      text-column -> gint: text-column
      inline-completion -> gboolean: inline-completion
      popup-completion -> gboolean: popup-completion
      popup-set-width -> gboolean: popup-set-width
      popup-single-match -> gboolean: popup-single-match
      inline-selection -> gboolean: inline-selection
      cell-area -> GtkCellArea: cell-area

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        cell_area: CellArea
        inline_completion: bool
        inline_selection: bool
        minimum_key_length: int
        model: typing.Optional[TreeModel]
        popup_completion: bool
        popup_set_width: bool
        popup_single_match: bool
        text_column: int

    props: Props = ...
    def __init__(
        self,
        cell_area: CellArea = ...,
        inline_completion: bool = ...,
        inline_selection: bool = ...,
        minimum_key_length: int = ...,
        model: typing.Optional[TreeModel] = ...,
        popup_completion: bool = ...,
        popup_set_width: bool = ...,
        popup_single_match: bool = ...,
        text_column: int = ...,
    ) -> None: ...
    def complete(self) -> None: ...
    def compute_prefix(self, key: str) -> typing.Optional[str]: ...
    def get_completion_prefix(self) -> typing.Optional[str]: ...
    def get_entry(self) -> Widget: ...
    def get_inline_completion(self) -> bool: ...
    def get_inline_selection(self) -> bool: ...
    def get_minimum_key_length(self) -> int: ...
    def get_model(self) -> typing.Optional[TreeModel]: ...
    def get_popup_completion(self) -> bool: ...
    def get_popup_set_width(self) -> bool: ...
    def get_popup_single_match(self) -> bool: ...
    def get_text_column(self) -> int: ...
    def insert_prefix(self) -> None: ...
    @classmethod
    def new(cls) -> EntryCompletion: ...
    @classmethod
    def new_with_area(cls, area: CellArea) -> EntryCompletion: ...
    def set_inline_completion(self, inline_completion: bool) -> None: ...
    def set_inline_selection(self, inline_selection: bool) -> None: ...
    def set_match_func(
        self, func: typing.Callable[..., bool], *func_data: typing.Any
    ) -> None: ...
    def set_minimum_key_length(self, length: int) -> None: ...
    def set_model(self, model: typing.Optional[TreeModel] = None) -> None: ...
    def set_popup_completion(self, popup_completion: bool) -> None: ...
    def set_popup_set_width(self, popup_set_width: bool) -> None: ...
    def set_popup_single_match(self, popup_single_match: bool) -> None: ...
    def set_text_column(self, column: int) -> None: ...

class EventController(GObject.Object):
    """
    :Constructors:

    ::

        EventController(**properties)

    Object GtkEventController

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_current_event(self) -> typing.Optional[Gdk.Event]: ...
    def get_current_event_device(self) -> typing.Optional[Gdk.Device]: ...
    def get_current_event_state(self) -> Gdk.ModifierType: ...
    def get_current_event_time(self) -> int: ...
    def get_name(self) -> typing.Optional[str]: ...
    def get_propagation_limit(self) -> PropagationLimit: ...
    def get_propagation_phase(self) -> PropagationPhase: ...
    def get_widget(self) -> typing.Optional[Widget]: ...
    def reset(self) -> None: ...
    def set_name(self, name: typing.Optional[str] = None) -> None: ...
    def set_propagation_limit(self, limit: PropagationLimit) -> None: ...
    def set_propagation_phase(self, phase: PropagationPhase) -> None: ...
    def set_static_name(self, name: typing.Optional[str] = None) -> None: ...

class EventControllerClass(GObject.GPointer): ...

class EventControllerFocus(EventController):
    """
    :Constructors:

    ::

        EventControllerFocus(**properties)
        new() -> Gtk.EventController

    Object GtkEventControllerFocus

    Signals from GtkEventControllerFocus:
      enter ()
      leave ()

    Properties from GtkEventControllerFocus:
      is-focus -> gboolean: is-focus
      contains-focus -> gboolean: contains-focus

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        contains_focus: bool
        is_focus: bool
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def contains_focus(self) -> bool: ...
    def is_focus(self) -> bool: ...
    @classmethod
    def new(cls) -> EventControllerFocus: ...

class EventControllerFocusClass(GObject.GPointer): ...

class EventControllerKey(EventController):
    """
    :Constructors:

    ::

        EventControllerKey(**properties)
        new() -> Gtk.EventController

    Object GtkEventControllerKey

    Signals from GtkEventControllerKey:
      modifiers (GdkModifierType) -> gboolean
      key-pressed (guint, guint, GdkModifierType) -> gboolean
      key-released (guint, guint, GdkModifierType)
      im-update ()

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def forward(self, widget: Widget) -> bool: ...
    def get_group(self) -> int: ...
    def get_im_context(self) -> typing.Optional[IMContext]: ...
    @classmethod
    def new(cls) -> EventControllerKey: ...
    def set_im_context(self, im_context: typing.Optional[IMContext] = None) -> None: ...

class EventControllerKeyClass(GObject.GPointer): ...

class EventControllerLegacy(EventController):
    """
    :Constructors:

    ::

        EventControllerLegacy(**properties)
        new() -> Gtk.EventController

    Object GtkEventControllerLegacy

    Signals from GtkEventControllerLegacy:
      event (GdkEvent) -> gboolean

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> EventControllerLegacy: ...

class EventControllerLegacyClass(GObject.GPointer): ...

class EventControllerMotion(EventController):
    """
    :Constructors:

    ::

        EventControllerMotion(**properties)
        new() -> Gtk.EventController

    Object GtkEventControllerMotion

    Signals from GtkEventControllerMotion:
      enter (gdouble, gdouble)
      leave ()
      motion (gdouble, gdouble)

    Properties from GtkEventControllerMotion:
      is-pointer -> gboolean: is-pointer
      contains-pointer -> gboolean: contains-pointer

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        contains_pointer: bool
        is_pointer: bool
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def contains_pointer(self) -> bool: ...
    def is_pointer(self) -> bool: ...
    @classmethod
    def new(cls) -> EventControllerMotion: ...

class EventControllerMotionClass(GObject.GPointer): ...

class EventControllerScroll(EventController):
    """
    :Constructors:

    ::

        EventControllerScroll(**properties)
        new(flags:Gtk.EventControllerScrollFlags) -> Gtk.EventController

    Object GtkEventControllerScroll

    Signals from GtkEventControllerScroll:
      scroll-begin ()
      scroll (gdouble, gdouble) -> gboolean
      scroll-end ()
      decelerate (gdouble, gdouble)

    Properties from GtkEventControllerScroll:
      flags -> GtkEventControllerScrollFlags: flags

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        flags: EventControllerScrollFlags
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        flags: EventControllerScrollFlags = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_flags(self) -> EventControllerScrollFlags: ...
    def get_unit(self) -> Gdk.ScrollUnit: ...
    @classmethod
    def new(cls, flags: EventControllerScrollFlags) -> EventControllerScroll: ...
    def set_flags(self, flags: EventControllerScrollFlags) -> None: ...

class EventControllerScrollClass(GObject.GPointer): ...

# override
class EveryFilter(MultiFilter, Gio.ListModel[typing.Any], Buildable):
    """
    :Constructors:

    ::

        EveryFilter(**properties)
        new() -> Gtk.EveryFilter

    Object GtkEveryFilter

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Properties from GtkMultiFilter:
      item-type -> GType: item-type
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(MultiFilter.Props):
        item_type: typing.Type[typing.Any]
        n_items: int

    props: Props = ...
    @classmethod
    def new(cls) -> EveryFilter: ...

class EveryFilterClass(GObject.GPointer): ...

class Expander(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Expander(**properties)
        new(label:str=None) -> Gtk.Widget
        new_with_mnemonic(label:str=None) -> Gtk.Widget

    Object GtkExpander

    Signals from GtkExpander:
      activate ()

    Properties from GtkExpander:
      expanded -> gboolean: expanded
      label -> gchararray: label
      use-underline -> gboolean: use-underline
      use-markup -> gboolean: use-markup
      label-widget -> GtkWidget: label-widget
      resize-toplevel -> gboolean: resize-toplevel
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        expanded: bool
        label: typing.Optional[str]
        label_widget: typing.Optional[Widget]
        resize_toplevel: bool
        use_markup: bool
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        expanded: bool = ...,
        label: typing.Optional[str] = ...,
        label_widget: typing.Optional[Widget] = ...,
        resize_toplevel: bool = ...,
        use_markup: bool = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_expanded(self) -> bool: ...
    def get_label(self) -> typing.Optional[str]: ...
    def get_label_widget(self) -> typing.Optional[Widget]: ...
    def get_resize_toplevel(self) -> bool: ...
    def get_use_markup(self) -> bool: ...
    def get_use_underline(self) -> bool: ...
    @classmethod
    def new(cls, label: typing.Optional[str] = None) -> Expander: ...
    @classmethod
    def new_with_mnemonic(cls, label: typing.Optional[str] = None) -> Expander: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_expanded(self, expanded: bool) -> None: ...
    def set_label(self, label: typing.Optional[str] = None) -> None: ...
    def set_label_widget(
        self, label_widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_resize_toplevel(self, resize_toplevel: bool) -> None: ...
    def set_use_markup(self, use_markup: bool) -> None: ...
    def set_use_underline(self, use_underline: bool) -> None: ...

class Expression(gi.Fundamental):
    """
    :Constructors:

    ::

        Expression(**properties)
    """
    def bind(
        self,
        target: GObject.Object,
        property: str,
        this_: typing.Optional[GObject.Object] = None,
    ) -> ExpressionWatch: ...
    def evaluate(
        self, this_: typing.Optional[GObject.Object], value: typing.Any
    ) -> bool: ...
    def get_value_type(self) -> typing.Type[typing.Any]: ...
    def is_static(self) -> bool: ...
    def ref(self) -> Expression: ...
    def unref(self) -> None: ...
    def watch(
        self,
        this_: typing.Optional[GObject.Object],
        notify: typing.Callable[..., None],
        *user_data: typing.Any,
    ) -> ExpressionWatch: ...

class ExpressionWatch(GObject.GBoxed):
    def evaluate(self, value: typing.Any) -> bool: ...
    def ref(self) -> ExpressionWatch: ...
    def unref(self) -> None: ...
    def unwatch(self) -> None: ...

class FileChooser(GObject.GInterface):
    """
    Interface GtkFileChooser

    Signals from GObject:
      notify (GParam)
    """
    def add_choice(
        self,
        id: str,
        label: str,
        options: typing.Optional[typing.Sequence[str]] = None,
        option_labels: typing.Optional[typing.Sequence[str]] = None,
    ) -> None: ...
    def add_filter(self, filter: FileFilter) -> None: ...
    def add_shortcut_folder(self, folder: Gio.File) -> bool: ...
    def get_action(self) -> FileChooserAction: ...
    def get_choice(self, id: str) -> typing.Optional[str]: ...
    def get_create_folders(self) -> bool: ...
    def get_current_folder(self) -> typing.Optional[Gio.File]: ...
    def get_current_name(self) -> typing.Optional[str]: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    # override
    def get_files(self) -> Gio.ListModel[typing.Any]: ...
    def get_filter(self) -> typing.Optional[FileFilter]: ...
    # override
    def get_filters(self) -> Gio.ListModel[FileFilter]: ...
    def get_select_multiple(self) -> bool: ...
    # override
    def get_shortcut_folders(self) -> Gio.ListModel[typing.Any]: ...
    def remove_choice(self, id: str) -> None: ...
    def remove_filter(self, filter: FileFilter) -> None: ...
    def remove_shortcut_folder(self, folder: Gio.File) -> bool: ...
    def set_action(self, action: FileChooserAction) -> None: ...
    def set_choice(self, id: str, option: str) -> None: ...
    def set_create_folders(self, create_folders: bool) -> None: ...
    def set_current_folder(self, file: typing.Optional[Gio.File] = None) -> bool: ...
    def set_current_name(self, name: str) -> None: ...
    def set_file(self, file: Gio.File) -> bool: ...
    def set_filter(self, filter: FileFilter) -> None: ...
    def set_select_multiple(self, select_multiple: bool) -> None: ...

class FileChooserDialog(
    Dialog,
    Accessible,
    Buildable,
    ConstraintTarget,
    FileChooser,
    Native,
    Root,
    ShortcutManager,
):
    """
    :Constructors:

    ::

        FileChooserDialog(**properties)

    Object GtkFileChooserDialog

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(Dialog.Props):
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action: FileChooserAction
        create_folders: bool
        filter: typing.Optional[FileFilter]
        filters: Gio.ListModel[FileFilter]
        select_multiple: bool
        shortcut_folders: Gio.ListModel[typing.Any]
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action: FileChooserAction = ...,
        create_folders: bool = ...,
        filter: FileFilter = ...,
        select_multiple: bool = ...,
    ) -> None: ...

class FileChooserNative(NativeDialog, FileChooser):
    """
    :Constructors:

    ::

        FileChooserNative(**properties)
        new(title:str=None, parent:Gtk.Window=None, action:Gtk.FileChooserAction, accept_label:str=None, cancel_label:str=None) -> Gtk.FileChooserNative

    Object GtkFileChooserNative

    Properties from GtkFileChooserNative:
      accept-label -> gchararray: accept-label
      cancel-label -> gchararray: cancel-label

    Signals from GtkNativeDialog:
      response (gint)

    Properties from GtkNativeDialog:
      title -> gchararray: title
      visible -> gboolean: visible
      modal -> gboolean: modal
      transient-for -> GtkWindow: transient-for

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(NativeDialog.Props):
        accept_label: typing.Optional[str]
        cancel_label: typing.Optional[str]
        modal: bool
        title: typing.Optional[str]
        transient_for: typing.Optional[Window]
        visible: bool
        action: FileChooserAction
        create_folders: bool
        filter: typing.Optional[FileFilter]
        filters: Gio.ListModel[FileFilter]
        select_multiple: bool
        shortcut_folders: Gio.ListModel[typing.Any]

    props: Props = ...
    def __init__(
        self,
        accept_label: typing.Optional[str] = ...,
        cancel_label: typing.Optional[str] = ...,
        modal: bool = ...,
        title: str = ...,
        transient_for: typing.Optional[Window] = ...,
        visible: bool = ...,
        action: FileChooserAction = ...,
        create_folders: bool = ...,
        filter: FileFilter = ...,
        select_multiple: bool = ...,
    ) -> None: ...
    def get_accept_label(self) -> typing.Optional[str]: ...
    def get_cancel_label(self) -> typing.Optional[str]: ...
    @classmethod
    def new(
        cls,
        title: typing.Optional[str],
        parent: typing.Optional[Window],
        action: FileChooserAction,
        accept_label: typing.Optional[str] = None,
        cancel_label: typing.Optional[str] = None,
    ) -> FileChooserNative: ...
    def set_accept_label(self, accept_label: typing.Optional[str] = None) -> None: ...
    def set_cancel_label(self, cancel_label: typing.Optional[str] = None) -> None: ...

class FileChooserNativeClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileChooserNativeClass()
    """

    parent_class: NativeDialogClass = ...

class FileChooserWidget(Widget, Accessible, Buildable, ConstraintTarget, FileChooser):
    """
    :Constructors:

    ::

        FileChooserWidget(**properties)
        new(action:Gtk.FileChooserAction) -> Gtk.Widget

    Object GtkFileChooserWidget

    Signals from GtkFileChooserWidget:
      location-popup (gchararray)
      location-popup-on-paste ()
      location-toggle-popup ()
      up-folder ()
      down-folder ()
      home-folder ()
      desktop-folder ()
      quick-bookmark (gint)
      show-hidden ()
      search-shortcut ()
      recent-shortcut ()
      places-shortcut ()

    Properties from GtkFileChooserWidget:
      search-mode -> gboolean: search-mode
      subtitle -> gchararray: subtitle
      show-time -> gboolean: show-time

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(Widget.Props):
        search_mode: bool
        show_time: bool
        subtitle: str
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action: FileChooserAction
        create_folders: bool
        filter: typing.Optional[FileFilter]
        filters: Gio.ListModel[FileFilter]
        select_multiple: bool
        shortcut_folders: Gio.ListModel[typing.Any]

    props: Props = ...
    def __init__(
        self,
        search_mode: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action: FileChooserAction = ...,
        create_folders: bool = ...,
        filter: FileFilter = ...,
        select_multiple: bool = ...,
    ) -> None: ...
    @classmethod
    def new(cls, action: FileChooserAction) -> FileChooserWidget: ...

class FileDialog(GObject.Object):
    """
    :Constructors:

    ::

        FileDialog(**properties)
        new() -> Gtk.FileDialog

    Object GtkFileDialog

    Properties from GtkFileDialog:
      accept-label -> gchararray: accept-label
      default-filter -> GtkFileFilter: default-filter
      filters -> GListModel: filters
      initial-file -> GFile: initial-file
      initial-folder -> GFile: initial-folder
      initial-name -> gchararray: initial-name
      modal -> gboolean: modal
      title -> gchararray: title

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(GObject.Object.Props):
        accept_label: typing.Optional[str]
        default_filter: typing.Optional[FileFilter]
        filters: typing.Optional[Gio.ListModel[FileFilter]]
        initial_file: typing.Optional[Gio.File]
        initial_folder: typing.Optional[Gio.File]
        initial_name: typing.Optional[str]
        modal: bool
        title: str

    props: Props = ...
    # override
    def __init__(
        self,
        accept_label: typing.Optional[str] = ...,
        default_filter: typing.Optional[FileFilter] = ...,
        filters: typing.Optional[Gio.ListModel[FileFilter]] = ...,
        initial_file: typing.Optional[Gio.File] = ...,
        initial_folder: typing.Optional[Gio.File] = ...,
        initial_name: typing.Optional[str] = ...,
        modal: bool = ...,
        title: str = ...,
    ) -> None: ...
    def get_accept_label(self) -> typing.Optional[str]: ...
    def get_default_filter(self) -> typing.Optional[FileFilter]: ...
    # override
    def get_filters(self) -> typing.Optional[Gio.ListModel[FileFilter]]: ...
    def get_initial_file(self) -> typing.Optional[Gio.File]: ...
    def get_initial_folder(self) -> typing.Optional[Gio.File]: ...
    def get_initial_name(self) -> typing.Optional[str]: ...
    def get_modal(self) -> bool: ...
    def get_title(self) -> str: ...
    @classmethod
    def new(cls) -> FileDialog: ...
    def open(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def open_finish(self, result: Gio.AsyncResult) -> Gio.File: ...
    def open_multiple(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    # override
    def open_multiple_finish(
        self, result: Gio.AsyncResult
    ) -> Gio.ListModel[typing.Any]: ...
    def open_multiple_text_files(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    # override
    def open_multiple_text_files_finish(
        self, result: Gio.AsyncResult
    ) -> typing.Tuple[Gio.ListModel[typing.Any], str]: ...
    def open_text_file(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def open_text_file_finish(
        self, result: Gio.AsyncResult
    ) -> typing.Tuple[Gio.File, str]: ...
    def save(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def save_finish(self, result: Gio.AsyncResult) -> Gio.File: ...
    def save_text_file(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def save_text_file_finish(
        self, result: Gio.AsyncResult
    ) -> typing.Tuple[Gio.File, str, str]: ...
    def select_folder(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def select_folder_finish(self, result: Gio.AsyncResult) -> Gio.File: ...
    def select_multiple_folders(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    # override
    def select_multiple_folders_finish(
        self, result: Gio.AsyncResult
    ) -> Gio.ListModel[typing.Any]: ...
    def set_accept_label(self, accept_label: typing.Optional[str] = None) -> None: ...
    def set_default_filter(
        self, filter: typing.Optional[FileFilter] = None
    ) -> None: ...
    # override
    def set_filters(
        self, filters: typing.Optional[Gio.ListModel[FileFilter]] = None
    ) -> None: ...
    def set_initial_file(self, file: typing.Optional[Gio.File] = None) -> None: ...
    def set_initial_folder(self, folder: typing.Optional[Gio.File] = None) -> None: ...
    def set_initial_name(self, name: typing.Optional[str] = None) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_title(self, title: str) -> None: ...

class FileDialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileDialogClass()
    """

    parent_class: GObject.ObjectClass = ...

class FileFilter(Filter, Buildable):
    """
    :Constructors:

    ::

        FileFilter(**properties)
        new() -> Gtk.FileFilter
        new_from_gvariant(variant:GLib.Variant) -> Gtk.FileFilter

    Object GtkFileFilter

    Properties from GtkFileFilter:
      name -> gchararray: name
      patterns -> GStrv: patterns
      mime-types -> GStrv: mime-types
      suffixes -> GStrv: suffixes

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Filter.Props):
        name: typing.Optional[str]
        mime_types: list[str]
        patterns: list[str]
        suffixes: list[str]

    props: Props = ...
    def __init__(
        self,
        mime_types: typing.Sequence[str] = ...,
        name: typing.Optional[str] = ...,
        patterns: typing.Sequence[str] = ...,
        suffixes: typing.Sequence[str] = ...,
    ) -> None: ...
    def add_mime_type(self, mime_type: str) -> None: ...
    def add_pattern(self, pattern: str) -> None: ...
    def add_pixbuf_formats(self) -> None: ...
    def add_suffix(self, suffix: str) -> None: ...
    def get_attributes(self) -> list[str]: ...
    def get_name(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls) -> FileFilter: ...
    @classmethod
    def new_from_gvariant(cls, variant: GLib.Variant) -> FileFilter: ...
    def set_name(self, name: typing.Optional[str] = None) -> None: ...
    def to_gvariant(self) -> GLib.Variant: ...

class FileLauncher(GObject.Object):
    """
    :Constructors:

    ::

        FileLauncher(**properties)
        new(file:Gio.File=None) -> Gtk.FileLauncher

    Object GtkFileLauncher

    Properties from GtkFileLauncher:
      file -> GFile: file
      always-ask -> gboolean: always-ask
      writable -> gboolean: writable

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        always_ask: bool
        file: typing.Optional[Gio.File]
        writable: bool

    props: Props = ...
    def __init__(
        self,
        always_ask: bool = ...,
        file: typing.Optional[Gio.File] = ...,
        writable: bool = ...,
    ) -> None: ...
    def get_always_ask(self) -> bool: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_writable(self) -> bool: ...
    def launch(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def launch_finish(self, result: Gio.AsyncResult) -> bool: ...
    @classmethod
    def new(cls, file: typing.Optional[Gio.File] = None) -> FileLauncher: ...
    def open_containing_folder(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def open_containing_folder_finish(self, result: Gio.AsyncResult) -> bool: ...
    def set_always_ask(self, always_ask: bool) -> None: ...
    def set_file(self, file: typing.Optional[Gio.File] = None) -> None: ...
    def set_writable(self, writable: bool) -> None: ...

class FileLauncherClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileLauncherClass()
    """

    parent_class: GObject.ObjectClass = ...

class Filter(GObject.Object):
    """
    :Constructors:

    ::

        Filter(**properties)

    Object GtkFilter

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    def changed(self, change: FilterChange) -> None: ...
    def do_get_strictness(self) -> FilterMatch: ...
    def do_match(self, item: typing.Optional[GObject.Object] = None) -> bool: ...
    def get_strictness(self) -> FilterMatch: ...
    def match(self, item: GObject.Object) -> bool: ...

class FilterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FilterClass()
    """

    parent_class: GObject.ObjectClass = ...
    match: typing.Callable[[Filter, typing.Optional[GObject.Object]], bool] = ...
    get_strictness: typing.Callable[[Filter], FilterMatch] = ...

# override
class FilterListModel(GObject.Object, Gio.ListModel[typing.Any], SectionModel):
    """
    :Constructors:

    ::

        FilterListModel(**properties)
        new(model:Gio.ListModel=None, filter:Gtk.Filter=None) -> Gtk.FilterListModel

    Object GtkFilterListModel

    Properties from GtkFilterListModel:
      filter -> GtkFilter: filter
      incremental -> gboolean: incremental
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items
      pending -> guint: pending
      watch-items -> gboolean: watch-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        filter: typing.Optional[Filter]
        incremental: bool
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int
        pending: int
        watch_items: bool

    props: Props = ...
    def __init__(
        self,
        filter: typing.Optional[Filter] = ...,
        incremental: bool = ...,
        model: typing.Optional[Gio.ListModel[typing.Any]] = ...,
        watch_items: bool = ...,
    ) -> None: ...
    def get_filter(self) -> typing.Optional[Filter]: ...
    def get_incremental(self) -> bool: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_pending(self) -> int: ...
    def get_watch_items(self) -> bool: ...
    @classmethod
    def new(
        cls,
        model: typing.Optional[Gio.ListModel[typing.Any]] = None,
        filter: typing.Optional[Filter] = None,
    ) -> FilterListModel: ...
    def set_filter(self, filter: typing.Optional[Filter] = None) -> None: ...
    def set_incremental(self, incremental: bool) -> None: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...
    def set_watch_items(self, watch_items: bool) -> None: ...

class FilterListModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FilterListModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class Fixed(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Fixed(**properties)
        new() -> Gtk.Widget

    Object GtkFixed

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child_position(self, widget: Widget) -> typing.Tuple[float, float]: ...
    def get_child_transform(self, widget: Widget) -> typing.Optional[Gsk.Transform]: ...
    def move(self, widget: Widget, x: float, y: float) -> None: ...
    @classmethod
    def new(cls) -> Fixed: ...
    def put(self, widget: Widget, x: float, y: float) -> None: ...
    def remove(self, widget: Widget) -> None: ...
    def set_child_transform(
        self, widget: Widget, transform: typing.Optional[Gsk.Transform] = None
    ) -> None: ...

class FixedClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FixedClass()
    """

    parent_class: WidgetClass = ...
    padding: list[None] = ...

class FixedLayout(LayoutManager):
    """
    :Constructors:

    ::

        FixedLayout(**properties)
        new() -> Gtk.LayoutManager

    Object GtkFixedLayout

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(cls) -> FixedLayout: ...

class FixedLayoutChild(LayoutChild):
    """
    :Constructors:

    ::

        FixedLayoutChild(**properties)

    Object GtkFixedLayoutChild

    Properties from GtkFixedLayoutChild:
      transform -> GskTransform: transform

    Properties from GtkLayoutChild:
      layout-manager -> GtkLayoutManager: layout-manager
      child-widget -> GtkWidget: child-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutChild.Props):
        transform: typing.Optional[Gsk.Transform]
        child_widget: Widget
        layout_manager: LayoutManager

    props: Props = ...
    def __init__(
        self,
        transform: Gsk.Transform = ...,
        child_widget: Widget = ...,
        layout_manager: LayoutManager = ...,
    ) -> None: ...
    def get_transform(self) -> typing.Optional[Gsk.Transform]: ...
    def set_transform(self, transform: Gsk.Transform) -> None: ...

class FixedLayoutChildClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FixedLayoutChildClass()
    """

    parent_class: LayoutChildClass = ...

class FixedLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FixedLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

# override
class FlattenListModel(GObject.Object, Gio.ListModel[typing.Any], SectionModel):
    """
    :Constructors:

    ::

        FlattenListModel(**properties)
        new(model:Gio.ListModel=None) -> Gtk.FlattenListModel

    Object GtkFlattenListModel

    Properties from GtkFlattenListModel:
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int

    props: Props = ...
    def __init__(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = ...
    ) -> None: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_model_for_item(
        self, position: int
    ) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    @classmethod
    def new(
        cls, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> FlattenListModel: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...

class FlattenListModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FlattenListModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class FlowBox(Widget, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        FlowBox(**properties)
        new() -> Gtk.Widget

    Object GtkFlowBox

    Signals from GtkFlowBox:
      child-activated (GtkFlowBoxChild)
      selected-children-changed ()
      activate-cursor-child ()
      toggle-cursor-child ()
      move-cursor (GtkMovementStep, gint, gboolean, gboolean) -> gboolean
      select-all ()
      unselect-all ()

    Properties from GtkFlowBox:
      homogeneous -> gboolean: homogeneous
      column-spacing -> guint: column-spacing
      row-spacing -> guint: row-spacing
      min-children-per-line -> guint: min-children-per-line
      max-children-per-line -> guint: max-children-per-line
      selection-mode -> GtkSelectionMode: selection-mode
      activate-on-single-click -> gboolean: activate-on-single-click
      accept-unpaired-release -> gboolean: accept-unpaired-release

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        accept_unpaired_release: bool
        activate_on_single_click: bool
        column_spacing: int
        homogeneous: bool
        max_children_per_line: int
        min_children_per_line: int
        row_spacing: int
        selection_mode: SelectionMode
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        accept_unpaired_release: bool = ...,
        activate_on_single_click: bool = ...,
        column_spacing: int = ...,
        homogeneous: bool = ...,
        max_children_per_line: int = ...,
        min_children_per_line: int = ...,
        row_spacing: int = ...,
        selection_mode: SelectionMode = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def append(self, child: Widget) -> None: ...
    # override
    def bind_model(
        self,
        model: typing.Optional[Gio.ListModel[typing.Any]],
        create_widget_func: typing.Callable[..., Widget],
        *user_data: typing.Any,
    ) -> None: ...
    def get_activate_on_single_click(self) -> bool: ...
    def get_child_at_index(self, idx: int) -> typing.Optional[FlowBoxChild]: ...
    def get_child_at_pos(self, x: int, y: int) -> typing.Optional[FlowBoxChild]: ...
    def get_column_spacing(self) -> int: ...
    def get_homogeneous(self) -> bool: ...
    def get_max_children_per_line(self) -> int: ...
    def get_min_children_per_line(self) -> int: ...
    def get_row_spacing(self) -> int: ...
    def get_selected_children(self) -> list[FlowBoxChild]: ...
    def get_selection_mode(self) -> SelectionMode: ...
    def insert(self, widget: Widget, position: int) -> None: ...
    def invalidate_filter(self) -> None: ...
    def invalidate_sort(self) -> None: ...
    @classmethod
    def new(cls) -> FlowBox: ...
    def prepend(self, child: Widget) -> None: ...
    def remove(self, widget: Widget) -> None: ...
    def remove_all(self) -> None: ...
    def select_all(self) -> None: ...
    def select_child(self, child: FlowBoxChild) -> None: ...
    def selected_foreach(
        self, func: typing.Callable[..., None], *data: typing.Any
    ) -> None: ...
    def set_activate_on_single_click(self, single: bool) -> None: ...
    def set_column_spacing(self, spacing: int) -> None: ...
    def set_filter_func(
        self,
        filter_func: typing.Optional[typing.Callable[..., bool]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_hadjustment(self, adjustment: Adjustment) -> None: ...
    def set_homogeneous(self, homogeneous: bool) -> None: ...
    def set_max_children_per_line(self, n_children: int) -> None: ...
    def set_min_children_per_line(self, n_children: int) -> None: ...
    def set_row_spacing(self, spacing: int) -> None: ...
    def set_selection_mode(self, mode: SelectionMode) -> None: ...
    def set_sort_func(
        self,
        sort_func: typing.Optional[typing.Callable[..., int]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_vadjustment(self, adjustment: Adjustment) -> None: ...
    def unselect_all(self) -> None: ...
    def unselect_child(self, child: FlowBoxChild) -> None: ...

class FlowBoxChild(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        FlowBoxChild(**properties)
        new() -> Gtk.Widget

    Object GtkFlowBoxChild

    Signals from GtkFlowBoxChild:
      activate ()

    Properties from GtkFlowBoxChild:
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def changed(self) -> None: ...
    def do_activate(self) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_index(self) -> int: ...
    def is_selected(self) -> bool: ...
    @classmethod
    def new(cls) -> FlowBoxChild: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...

class FlowBoxChildClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FlowBoxChildClass()
    """

    parent_class: WidgetClass = ...
    activate: typing.Callable[[FlowBoxChild], None] = ...
    padding: list[None] = ...

class FontButton(Widget, Accessible, Buildable, ConstraintTarget, FontChooser):
    """
    :Constructors:

    ::

        FontButton(**properties)
        new() -> Gtk.Widget
        new_with_font(fontname:str) -> Gtk.Widget

    Object GtkFontButton

    Signals from GtkFontButton:
      activate ()
      font-set ()

    Properties from GtkFontButton:
      title -> gchararray: title
      modal -> gboolean: modal
      use-font -> gboolean: use-font
      use-size -> gboolean: use-size

    Signals from GtkFontChooser:
      font-activated (gchararray)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        modal: bool
        title: str
        use_font: bool
        use_size: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        font: typing.Optional[str]
        font_desc: typing.Optional[Pango.FontDescription]
        font_features: str
        language: str
        level: FontChooserLevel
        preview_text: str
        show_preview_entry: bool

    props: Props = ...
    def __init__(
        self,
        modal: bool = ...,
        title: str = ...,
        use_font: bool = ...,
        use_size: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        language: str = ...,
        level: FontChooserLevel = ...,
        preview_text: str = ...,
        show_preview_entry: bool = ...,
    ) -> None: ...
    def get_modal(self) -> bool: ...
    def get_title(self) -> str: ...
    def get_use_font(self) -> bool: ...
    def get_use_size(self) -> bool: ...
    @classmethod
    def new(cls) -> FontButton: ...
    @classmethod
    def new_with_font(cls, fontname: str) -> FontButton: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_title(self, title: str) -> None: ...
    def set_use_font(self, use_font: bool) -> None: ...
    def set_use_size(self, use_size: bool) -> None: ...

class FontChooser(GObject.GInterface):
    """
    Interface GtkFontChooser

    Signals from GObject:
      notify (GParam)
    """
    def get_font(self) -> typing.Optional[str]: ...
    def get_font_desc(self) -> typing.Optional[Pango.FontDescription]: ...
    def get_font_face(self) -> typing.Optional[Pango.FontFace]: ...
    def get_font_family(self) -> typing.Optional[Pango.FontFamily]: ...
    def get_font_features(self) -> str: ...
    def get_font_map(self) -> typing.Optional[Pango.FontMap]: ...
    def get_font_size(self) -> int: ...
    def get_language(self) -> str: ...
    def get_level(self) -> FontChooserLevel: ...
    def get_preview_text(self) -> str: ...
    def get_show_preview_entry(self) -> bool: ...
    def set_filter_func(
        self,
        filter: typing.Optional[typing.Callable[..., bool]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_font(self, fontname: str) -> None: ...
    def set_font_desc(self, font_desc: Pango.FontDescription) -> None: ...
    def set_font_map(self, fontmap: typing.Optional[Pango.FontMap] = None) -> None: ...
    def set_language(self, language: str) -> None: ...
    def set_level(self, level: FontChooserLevel) -> None: ...
    def set_preview_text(self, text: str) -> None: ...
    def set_show_preview_entry(self, show_preview_entry: bool) -> None: ...

class FontChooserDialog(
    Dialog,
    Accessible,
    Buildable,
    ConstraintTarget,
    FontChooser,
    Native,
    Root,
    ShortcutManager,
):
    """
    :Constructors:

    ::

        FontChooserDialog(**properties)
        new(title:str=None, parent:Gtk.Window=None) -> Gtk.Widget

    Object GtkFontChooserDialog

    Signals from GtkFontChooser:
      font-activated (gchararray)

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Dialog.Props):
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        font: typing.Optional[str]
        font_desc: typing.Optional[Pango.FontDescription]
        font_features: str
        language: str
        level: FontChooserLevel
        preview_text: str
        show_preview_entry: bool
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        language: str = ...,
        level: FontChooserLevel = ...,
        preview_text: str = ...,
        show_preview_entry: bool = ...,
    ) -> None: ...
    @classmethod
    def new(
        cls, title: typing.Optional[str] = None, parent: typing.Optional[Window] = None
    ) -> FontChooserDialog: ...

class FontChooserIface(GObject.GPointer):
    """
    :Constructors:

    ::

        FontChooserIface()
    """

    base_iface: GObject.TypeInterface = ...
    get_font_family: typing.Callable[
        [FontChooser], typing.Optional[Pango.FontFamily]
    ] = ...
    get_font_face: typing.Callable[[FontChooser], typing.Optional[Pango.FontFace]] = ...
    get_font_size: typing.Callable[[FontChooser], int] = ...
    set_filter_func: typing.Callable[..., None] = ...
    font_activated: typing.Callable[[FontChooser, str], None] = ...
    set_font_map: typing.Callable[
        [FontChooser, typing.Optional[Pango.FontMap]], None
    ] = ...
    get_font_map: typing.Callable[[FontChooser], typing.Optional[Pango.FontMap]] = ...
    padding: list[None] = ...

class FontChooserWidget(Widget, Accessible, Buildable, ConstraintTarget, FontChooser):
    """
    :Constructors:

    ::

        FontChooserWidget(**properties)
        new() -> Gtk.Widget

    Object GtkFontChooserWidget

    Properties from GtkFontChooserWidget:
      tweak-action -> GAction: tweak-action

    Signals from GtkFontChooser:
      font-activated (gchararray)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        tweak_action: Gio.Action
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        font: typing.Optional[str]
        font_desc: typing.Optional[Pango.FontDescription]
        font_features: str
        language: str
        level: FontChooserLevel
        preview_text: str
        show_preview_entry: bool

    props: Props = ...
    def __init__(
        self,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        language: str = ...,
        level: FontChooserLevel = ...,
        preview_text: str = ...,
        show_preview_entry: bool = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> FontChooserWidget: ...

class FontDialog(GObject.Object):
    """
    :Constructors:

    ::

        FontDialog(**properties)
        new() -> Gtk.FontDialog

    Object GtkFontDialog

    Properties from GtkFontDialog:
      title -> gchararray: title
      modal -> gboolean: modal
      language -> PangoLanguage: language
      font-map -> PangoFontMap: font-map
      filter -> GtkFilter: filter

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        filter: typing.Optional[Filter]
        font_map: typing.Optional[Pango.FontMap]
        language: typing.Optional[Pango.Language]
        modal: bool
        title: str

    props: Props = ...
    def __init__(
        self,
        filter: typing.Optional[Filter] = ...,
        font_map: typing.Optional[Pango.FontMap] = ...,
        language: Pango.Language = ...,
        modal: bool = ...,
        title: str = ...,
    ) -> None: ...
    def choose_face(
        self,
        parent: typing.Optional[Window] = None,
        initial_value: typing.Optional[Pango.FontFace] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def choose_face_finish(self, result: Gio.AsyncResult) -> Pango.FontFace: ...
    def choose_family(
        self,
        parent: typing.Optional[Window] = None,
        initial_value: typing.Optional[Pango.FontFamily] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def choose_family_finish(self, result: Gio.AsyncResult) -> Pango.FontFamily: ...
    def choose_font(
        self,
        parent: typing.Optional[Window] = None,
        initial_value: typing.Optional[Pango.FontDescription] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def choose_font_and_features(
        self,
        parent: typing.Optional[Window] = None,
        initial_value: typing.Optional[Pango.FontDescription] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def choose_font_and_features_finish(
        self, result: Gio.AsyncResult
    ) -> typing.Tuple[bool, Pango.FontDescription, str, Pango.Language]: ...
    def choose_font_finish(self, result: Gio.AsyncResult) -> Pango.FontDescription: ...
    def get_filter(self) -> typing.Optional[Filter]: ...
    def get_font_map(self) -> typing.Optional[Pango.FontMap]: ...
    def get_language(self) -> typing.Optional[Pango.Language]: ...
    def get_modal(self) -> bool: ...
    def get_title(self) -> str: ...
    @classmethod
    def new(cls) -> FontDialog: ...
    def set_filter(self, filter: typing.Optional[Filter] = None) -> None: ...
    def set_font_map(self, fontmap: typing.Optional[Pango.FontMap] = None) -> None: ...
    def set_language(self, language: Pango.Language) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_title(self, title: str) -> None: ...

class FontDialogButton(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        FontDialogButton(**properties)
        new(dialog:Gtk.FontDialog=None) -> Gtk.Widget

    Object GtkFontDialogButton

    Signals from GtkFontDialogButton:
      activate ()

    Properties from GtkFontDialogButton:
      dialog -> GtkFontDialog: dialog
      level -> GtkFontLevel: level
      font-desc -> PangoFontDescription: font-desc
      font-features -> gchararray: font-features
      language -> PangoLanguage: language
      use-font -> gboolean: use-font
      use-size -> gboolean: use-size

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        dialog: typing.Optional[FontDialog]
        font_desc: typing.Optional[Pango.FontDescription]
        font_features: typing.Optional[str]
        language: typing.Optional[Pango.Language]
        level: FontLevel
        use_font: bool
        use_size: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        dialog: FontDialog = ...,
        font_desc: Pango.FontDescription = ...,
        font_features: typing.Optional[str] = ...,
        language: typing.Optional[Pango.Language] = ...,
        level: FontLevel = ...,
        use_font: bool = ...,
        use_size: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_dialog(self) -> typing.Optional[FontDialog]: ...
    def get_font_desc(self) -> typing.Optional[Pango.FontDescription]: ...
    def get_font_features(self) -> typing.Optional[str]: ...
    def get_language(self) -> typing.Optional[Pango.Language]: ...
    def get_level(self) -> FontLevel: ...
    def get_use_font(self) -> bool: ...
    def get_use_size(self) -> bool: ...
    @classmethod
    def new(cls, dialog: typing.Optional[FontDialog] = None) -> FontDialogButton: ...
    def set_dialog(self, dialog: FontDialog) -> None: ...
    def set_font_desc(self, font_desc: Pango.FontDescription) -> None: ...
    def set_font_features(self, font_features: typing.Optional[str] = None) -> None: ...
    def set_language(
        self, language: typing.Optional[Pango.Language] = None
    ) -> None: ...
    def set_level(self, level: FontLevel) -> None: ...
    def set_use_font(self, use_font: bool) -> None: ...
    def set_use_size(self, use_size: bool) -> None: ...

class FontDialogButtonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FontDialogButtonClass()
    """

    parent_class: WidgetClass = ...

class FontDialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FontDialogClass()
    """

    parent_class: GObject.ObjectClass = ...

class Frame(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Frame(**properties)
        new(label:str=None) -> Gtk.Widget

    Object GtkFrame

    Properties from GtkFrame:
      label -> gchararray: label
      label-xalign -> gfloat: label-xalign
      label-widget -> GtkWidget: label-widget
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        label: typing.Optional[str]
        label_widget: typing.Optional[Widget]
        label_xalign: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        label: typing.Optional[str] = ...,
        label_widget: typing.Optional[Widget] = ...,
        label_xalign: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def do_compute_child_allocation(self, allocation: Gdk.Rectangle) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_label(self) -> typing.Optional[str]: ...
    def get_label_align(self) -> float: ...
    def get_label_widget(self) -> typing.Optional[Widget]: ...
    @classmethod
    def new(cls, label: typing.Optional[str] = None) -> Frame: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_label(self, label: typing.Optional[str] = None) -> None: ...
    def set_label_align(self, xalign: float) -> None: ...
    def set_label_widget(
        self, label_widget: typing.Optional[Widget] = None
    ) -> None: ...

class FrameClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FrameClass()
    """

    parent_class: WidgetClass = ...
    compute_child_allocation: typing.Callable[[Frame, Gdk.Rectangle], None] = ...
    padding: list[None] = ...

class GLArea(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        GLArea(**properties)
        new() -> Gtk.Widget

    Object GtkGLArea

    Signals from GtkGLArea:
      resize (gint, gint)
      render (GdkGLContext) -> gboolean
      create-context () -> GdkGLContext

    Properties from GtkGLArea:
      context -> GdkGLContext: context
      has-depth-buffer -> gboolean: has-depth-buffer
      has-stencil-buffer -> gboolean: has-stencil-buffer
      use-es -> gboolean: use-es
      allowed-apis -> GdkGLAPI: allowed-apis
      api -> GdkGLAPI: api
      auto-render -> gboolean: auto-render

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        allowed_apis: Gdk.GLAPI
        api: Gdk.GLAPI
        auto_render: bool
        context: typing.Optional[Gdk.GLContext]
        has_depth_buffer: bool
        has_stencil_buffer: bool
        use_es: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        allowed_apis: Gdk.GLAPI = ...,
        auto_render: bool = ...,
        has_depth_buffer: bool = ...,
        has_stencil_buffer: bool = ...,
        use_es: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def attach_buffers(self) -> None: ...
    def do_render(self, context: Gdk.GLContext) -> bool: ...
    def do_resize(self, width: int, height: int) -> None: ...
    def get_allowed_apis(self) -> Gdk.GLAPI: ...
    def get_api(self) -> Gdk.GLAPI: ...
    def get_auto_render(self) -> bool: ...
    def get_context(self) -> typing.Optional[Gdk.GLContext]: ...
    def get_error(self) -> typing.Optional[GLib.Error]: ...
    def get_has_depth_buffer(self) -> bool: ...
    def get_has_stencil_buffer(self) -> bool: ...
    def get_required_version(self) -> typing.Tuple[int, int]: ...
    def get_use_es(self) -> bool: ...
    def make_current(self) -> None: ...
    @classmethod
    def new(cls) -> GLArea: ...
    def queue_render(self) -> None: ...
    def set_allowed_apis(self, apis: Gdk.GLAPI) -> None: ...
    def set_auto_render(self, auto_render: bool) -> None: ...
    def set_error(self, error: typing.Optional[GLib.Error] = None) -> None: ...
    def set_has_depth_buffer(self, has_depth_buffer: bool) -> None: ...
    def set_has_stencil_buffer(self, has_stencil_buffer: bool) -> None: ...
    def set_required_version(self, major: int, minor: int) -> None: ...
    def set_use_es(self, use_es: bool) -> None: ...

class GLAreaClass(GObject.GPointer):
    """
    :Constructors:

    ::

        GLAreaClass()
    """

    parent_class: WidgetClass = ...
    render: typing.Callable[[GLArea, Gdk.GLContext], bool] = ...
    resize: typing.Callable[[GLArea, int, int], None] = ...
    create_context: None = ...

class Gesture(EventController):
    """
    :Constructors:

    ::

        Gesture(**properties)

    Object GtkGesture

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_bounding_box(self) -> typing.Tuple[bool, Gdk.Rectangle]: ...
    def get_bounding_box_center(self) -> typing.Tuple[bool, float, float]: ...
    def get_device(self) -> typing.Optional[Gdk.Device]: ...
    def get_group(self) -> list[Gesture]: ...
    def get_last_event(
        self, sequence: typing.Optional[Gdk.EventSequence] = None
    ) -> typing.Optional[Gdk.Event]: ...
    def get_last_updated_sequence(self) -> typing.Optional[Gdk.EventSequence]: ...
    def get_point(
        self, sequence: typing.Optional[Gdk.EventSequence] = None
    ) -> typing.Tuple[bool, float, float]: ...
    def get_sequence_state(self, sequence: Gdk.EventSequence) -> EventSequenceState: ...
    def get_sequences(self) -> list[Gdk.EventSequence]: ...
    def group(self, gesture: Gesture) -> None: ...
    def handles_sequence(
        self, sequence: typing.Optional[Gdk.EventSequence] = None
    ) -> bool: ...
    def is_active(self) -> bool: ...
    def is_grouped_with(self, other: Gesture) -> bool: ...
    def is_recognized(self) -> bool: ...
    def set_sequence_state(
        self, sequence: Gdk.EventSequence, state: EventSequenceState
    ) -> bool: ...
    def set_state(self, state: EventSequenceState) -> bool: ...
    def ungroup(self) -> None: ...

class GestureClass(GObject.GPointer): ...

class GestureClick(GestureSingle):
    """
    :Constructors:

    ::

        GestureClick(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureClick

    Signals from GtkGestureClick:
      pressed (gint, gdouble, gdouble)
      released (gint, gdouble, gdouble)
      stopped ()
      unpaired-release (gdouble, gdouble, guint, GdkEventSequence)

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureSingle.Props):
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> GestureClick: ...

class GestureClickClass(GObject.GPointer): ...

class GestureDrag(GestureSingle):
    """
    :Constructors:

    ::

        GestureDrag(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureDrag

    Signals from GtkGestureDrag:
      drag-begin (gdouble, gdouble)
      drag-end (gdouble, gdouble)
      drag-update (gdouble, gdouble)

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureSingle.Props):
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_offset(self) -> typing.Tuple[bool, float, float]: ...
    def get_start_point(self) -> typing.Tuple[bool, float, float]: ...
    @classmethod
    def new(cls) -> GestureDrag: ...

class GestureDragClass(GObject.GPointer): ...

class GestureLongPress(GestureSingle):
    """
    :Constructors:

    ::

        GestureLongPress(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureLongPress

    Signals from GtkGestureLongPress:
      cancelled ()
      pressed (gdouble, gdouble)

    Properties from GtkGestureLongPress:
      delay-factor -> gdouble: delay-factor

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureSingle.Props):
        delay_factor: float
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        delay_factor: float = ...,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_delay_factor(self) -> float: ...
    @classmethod
    def new(cls) -> GestureLongPress: ...
    def set_delay_factor(self, delay_factor: float) -> None: ...

class GestureLongPressClass(GObject.GPointer): ...

class GesturePan(GestureDrag):
    """
    :Constructors:

    ::

        GesturePan(**properties)
        new(orientation:Gtk.Orientation) -> Gtk.Gesture

    Object GtkGesturePan

    Signals from GtkGesturePan:
      pan (GtkPanDirection, gdouble)

    Properties from GtkGesturePan:
      orientation -> GtkOrientation: orientation

    Signals from GtkGestureDrag:
      drag-begin (gdouble, gdouble)
      drag-end (gdouble, gdouble)
      drag-update (gdouble, gdouble)

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureDrag.Props):
        orientation: Orientation
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        orientation: Orientation = ...,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_orientation(self) -> Orientation: ...
    @classmethod
    def new(cls, orientation: Orientation) -> GesturePan: ...
    def set_orientation(self, orientation: Orientation) -> None: ...

class GesturePanClass(GObject.GPointer): ...

class GestureRotate(Gesture):
    """
    :Constructors:

    ::

        GestureRotate(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureRotate

    Signals from GtkGestureRotate:
      angle-changed (gdouble, gdouble)

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(Gesture.Props):
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_angle_delta(self) -> float: ...
    @classmethod
    def new(cls) -> GestureRotate: ...

class GestureRotateClass(GObject.GPointer): ...

class GestureSingle(Gesture):
    """
    :Constructors:

    ::

        GestureSingle(**properties)

    Object GtkGestureSingle

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(Gesture.Props):
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_button(self) -> int: ...
    def get_current_button(self) -> int: ...
    def get_current_sequence(self) -> typing.Optional[Gdk.EventSequence]: ...
    def get_exclusive(self) -> bool: ...
    def get_touch_only(self) -> bool: ...
    def set_button(self, button: int) -> None: ...
    def set_exclusive(self, exclusive: bool) -> None: ...
    def set_touch_only(self, touch_only: bool) -> None: ...

class GestureSingleClass(GObject.GPointer): ...

class GestureStylus(GestureSingle):
    """
    :Constructors:

    ::

        GestureStylus(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureStylus

    Signals from GtkGestureStylus:
      motion (gdouble, gdouble)
      proximity (gdouble, gdouble)
      down (gdouble, gdouble)
      up (gdouble, gdouble)

    Properties from GtkGestureStylus:
      stylus-only -> gboolean: stylus-only

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureSingle.Props):
        stylus_only: bool
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        stylus_only: bool = ...,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_axes(
        self, axes: typing.Sequence[Gdk.AxisUse]
    ) -> typing.Tuple[bool, list[float]]: ...
    def get_axis(self, axis: Gdk.AxisUse) -> typing.Tuple[bool, float]: ...
    def get_backlog(self) -> typing.Tuple[bool, list[Gdk.TimeCoord]]: ...
    def get_device_tool(self) -> typing.Optional[Gdk.DeviceTool]: ...
    def get_stylus_only(self) -> bool: ...
    @classmethod
    def new(cls) -> GestureStylus: ...
    def set_stylus_only(self, stylus_only: bool) -> None: ...

class GestureStylusClass(GObject.GPointer): ...

class GestureSwipe(GestureSingle):
    """
    :Constructors:

    ::

        GestureSwipe(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureSwipe

    Signals from GtkGestureSwipe:
      swipe (gdouble, gdouble)

    Properties from GtkGestureSingle:
      touch-only -> gboolean: touch-only
      exclusive -> gboolean: exclusive
      button -> guint: button

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GestureSingle.Props):
        button: int
        exclusive: bool
        touch_only: bool
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        button: int = ...,
        exclusive: bool = ...,
        touch_only: bool = ...,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_velocity(self) -> typing.Tuple[bool, float, float]: ...
    @classmethod
    def new(cls) -> GestureSwipe: ...

class GestureSwipeClass(GObject.GPointer): ...

class GestureZoom(Gesture):
    """
    :Constructors:

    ::

        GestureZoom(**properties)
        new() -> Gtk.Gesture

    Object GtkGestureZoom

    Signals from GtkGestureZoom:
      scale-changed (gdouble)

    Signals from GtkGesture:
      cancel (GdkEventSequence)
      begin (GdkEventSequence)
      end (GdkEventSequence)
      update (GdkEventSequence)
      sequence-state-changed (GdkEventSequence, GtkEventSequenceState)

    Properties from GtkGesture:
      n-points -> guint: n-points

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(Gesture.Props):
        n_points: int
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        n_points: int = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def get_scale_delta(self) -> float: ...
    @classmethod
    def new(cls) -> GestureZoom: ...

class GestureZoomClass(GObject.GPointer): ...

class GraphicsOffload(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        GraphicsOffload(**properties)
        new(child:Gtk.Widget=None) -> Gtk.Widget

    Object GtkGraphicsOffload

    Properties from GtkGraphicsOffload:
      child -> GtkWidget: child
      enabled -> GtkGraphicsOffloadEnabled: enabled
      black-background -> gboolean: black-background

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        black_background: bool
        child: typing.Optional[Widget]
        enabled: GraphicsOffloadEnabled
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        black_background: bool = ...,
        child: typing.Optional[Widget] = ...,
        enabled: GraphicsOffloadEnabled = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_black_background(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_enabled(self) -> GraphicsOffloadEnabled: ...
    @classmethod
    def new(cls, child: typing.Optional[Widget] = None) -> GraphicsOffload: ...
    def set_black_background(self, value: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_enabled(self, enabled: GraphicsOffloadEnabled) -> None: ...

class GraphicsOffloadClass(GObject.GPointer):
    """
    :Constructors:

    ::

        GraphicsOffloadClass()
    """

    parent_class: WidgetClass = ...

class Grid(Widget, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        Grid(**properties)
        new() -> Gtk.Widget

    Object GtkGrid

    Properties from GtkGrid:
      row-spacing -> gint: row-spacing
      column-spacing -> gint: column-spacing
      row-homogeneous -> gboolean: row-homogeneous
      column-homogeneous -> gboolean: column-homogeneous
      baseline-row -> gint: baseline-row

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        baseline_row: int
        column_homogeneous: bool
        column_spacing: int
        row_homogeneous: bool
        row_spacing: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        baseline_row: int = ...,
        column_homogeneous: bool = ...,
        column_spacing: int = ...,
        row_homogeneous: bool = ...,
        row_spacing: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def attach(
        self, child: Widget, column: int, row: int, width: int, height: int
    ) -> None: ...
    def attach_next_to(
        self,
        child: Widget,
        sibling: typing.Optional[Widget],
        side: PositionType,
        width: int,
        height: int,
    ) -> None: ...
    def get_baseline_row(self) -> int: ...
    def get_child_at(self, column: int, row: int) -> typing.Optional[Widget]: ...
    def get_column_homogeneous(self) -> bool: ...
    def get_column_spacing(self) -> int: ...
    def get_row_baseline_position(self, row: int) -> BaselinePosition: ...
    def get_row_homogeneous(self) -> bool: ...
    def get_row_spacing(self) -> int: ...
    def insert_column(self, position: int) -> None: ...
    def insert_next_to(self, sibling: Widget, side: PositionType) -> None: ...
    def insert_row(self, position: int) -> None: ...
    @classmethod
    def new(cls) -> Grid: ...
    def query_child(self, child: Widget) -> typing.Tuple[int, int, int, int]: ...
    def remove(self, child: Widget) -> None: ...
    def remove_column(self, position: int) -> None: ...
    def remove_row(self, position: int) -> None: ...
    def set_baseline_row(self, row: int) -> None: ...
    def set_column_homogeneous(self, homogeneous: bool) -> None: ...
    def set_column_spacing(self, spacing: int) -> None: ...
    def set_row_baseline_position(self, row: int, pos: BaselinePosition) -> None: ...
    def set_row_homogeneous(self, homogeneous: bool) -> None: ...
    def set_row_spacing(self, spacing: int) -> None: ...

class GridClass(GObject.GPointer):
    """
    :Constructors:

    ::

        GridClass()
    """

    parent_class: WidgetClass = ...
    padding: list[None] = ...

class GridLayout(LayoutManager):
    """
    :Constructors:

    ::

        GridLayout(**properties)
        new() -> Gtk.LayoutManager

    Object GtkGridLayout

    Properties from GtkGridLayout:
      row-spacing -> gint: row-spacing
      column-spacing -> gint: column-spacing
      row-homogeneous -> gboolean: row-homogeneous
      column-homogeneous -> gboolean: column-homogeneous
      baseline-row -> gint: baseline-row

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutManager.Props):
        baseline_row: int
        column_homogeneous: bool
        column_spacing: int
        row_homogeneous: bool
        row_spacing: int

    props: Props = ...
    def __init__(
        self,
        baseline_row: int = ...,
        column_homogeneous: bool = ...,
        column_spacing: int = ...,
        row_homogeneous: bool = ...,
        row_spacing: int = ...,
    ) -> None: ...
    def get_baseline_row(self) -> int: ...
    def get_column_homogeneous(self) -> bool: ...
    def get_column_spacing(self) -> int: ...
    def get_row_baseline_position(self, row: int) -> BaselinePosition: ...
    def get_row_homogeneous(self) -> bool: ...
    def get_row_spacing(self) -> int: ...
    @classmethod
    def new(cls) -> GridLayout: ...
    def set_baseline_row(self, row: int) -> None: ...
    def set_column_homogeneous(self, homogeneous: bool) -> None: ...
    def set_column_spacing(self, spacing: int) -> None: ...
    def set_row_baseline_position(self, row: int, pos: BaselinePosition) -> None: ...
    def set_row_homogeneous(self, homogeneous: bool) -> None: ...
    def set_row_spacing(self, spacing: int) -> None: ...

class GridLayoutChild(LayoutChild):
    """
    :Constructors:

    ::

        GridLayoutChild(**properties)

    Object GtkGridLayoutChild

    Properties from GtkGridLayoutChild:
      column -> gint: column
      row -> gint: row
      column-span -> gint: column-span
      row-span -> gint: row-span

    Properties from GtkLayoutChild:
      layout-manager -> GtkLayoutManager: layout-manager
      child-widget -> GtkWidget: child-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutChild.Props):
        column: int
        column_span: int
        row: int
        row_span: int
        child_widget: Widget
        layout_manager: LayoutManager

    props: Props = ...
    def __init__(
        self,
        column: int = ...,
        column_span: int = ...,
        row: int = ...,
        row_span: int = ...,
        child_widget: Widget = ...,
        layout_manager: LayoutManager = ...,
    ) -> None: ...
    def get_column(self) -> int: ...
    def get_column_span(self) -> int: ...
    def get_row(self) -> int: ...
    def get_row_span(self) -> int: ...
    def set_column(self, column: int) -> None: ...
    def set_column_span(self, span: int) -> None: ...
    def set_row(self, row: int) -> None: ...
    def set_row_span(self, span: int) -> None: ...

class GridLayoutChildClass(GObject.GPointer):
    """
    :Constructors:

    ::

        GridLayoutChildClass()
    """

    parent_class: LayoutChildClass = ...

class GridLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        GridLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class GridView(
    ListBase, Accessible, Buildable, ConstraintTarget, Orientable, Scrollable
):
    """
    :Constructors:

    ::

        GridView(**properties)
        new(model:Gtk.SelectionModel=None, factory:Gtk.ListItemFactory=None) -> Gtk.Widget

    Object GtkGridView

    Signals from GtkGridView:
      activate (guint)

    Properties from GtkGridView:
      enable-rubberband -> gboolean: enable-rubberband
      factory -> GtkListItemFactory: factory
      max-columns -> guint: max-columns
      min-columns -> guint: min-columns
      model -> GtkSelectionModel: model
      single-click-activate -> gboolean: single-click-activate
      tab-behavior -> GtkListTabBehavior: tab-behavior

    Properties from GtkListBase:
      orientation -> GtkOrientation: orientation

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(ListBase.Props):
        enable_rubberband: bool
        factory: typing.Optional[ListItemFactory]
        max_columns: int
        min_columns: int
        model: typing.Optional[SelectionModel]
        single_click_activate: bool
        tab_behavior: ListTabBehavior
        orientation: Orientation
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    def __init__(
        self,
        enable_rubberband: bool = ...,
        factory: typing.Optional[ListItemFactory] = ...,
        max_columns: int = ...,
        min_columns: int = ...,
        model: typing.Optional[SelectionModel] = ...,
        single_click_activate: bool = ...,
        tab_behavior: ListTabBehavior = ...,
        orientation: Orientation = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def get_enable_rubberband(self) -> bool: ...
    def get_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_max_columns(self) -> int: ...
    def get_min_columns(self) -> int: ...
    def get_model(self) -> typing.Optional[SelectionModel]: ...
    def get_single_click_activate(self) -> bool: ...
    def get_tab_behavior(self) -> ListTabBehavior: ...
    @classmethod
    def new(
        cls,
        model: typing.Optional[SelectionModel] = None,
        factory: typing.Optional[ListItemFactory] = None,
    ) -> GridView: ...
    def scroll_to(
        self,
        pos: int,
        flags: ListScrollFlags,
        scroll: typing.Optional[ScrollInfo] = None,
    ) -> None: ...
    def set_enable_rubberband(self, enable_rubberband: bool) -> None: ...
    def set_factory(self, factory: typing.Optional[ListItemFactory] = None) -> None: ...
    def set_max_columns(self, max_columns: int) -> None: ...
    def set_min_columns(self, min_columns: int) -> None: ...
    def set_model(self, model: typing.Optional[SelectionModel] = None) -> None: ...
    def set_single_click_activate(self, single_click_activate: bool) -> None: ...
    def set_tab_behavior(self, tab_behavior: ListTabBehavior) -> None: ...

class GridViewClass(GObject.GPointer): ...

class HeaderBar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        HeaderBar(**properties)
        new() -> Gtk.Widget

    Object GtkHeaderBar

    Properties from GtkHeaderBar:
      title-widget -> GtkWidget: title-widget
      show-title-buttons -> gboolean: show-title-buttons
      decoration-layout -> gchararray: decoration-layout
      use-native-controls -> gboolean: use-native-controls

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        decoration_layout: typing.Optional[str]
        show_title_buttons: bool
        title_widget: typing.Optional[Widget]
        use_native_controls: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        decoration_layout: typing.Optional[str] = ...,
        show_title_buttons: bool = ...,
        title_widget: typing.Optional[Widget] = ...,
        use_native_controls: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_decoration_layout(self) -> typing.Optional[str]: ...
    def get_show_title_buttons(self) -> bool: ...
    def get_title_widget(self) -> typing.Optional[Widget]: ...
    def get_use_native_controls(self) -> bool: ...
    @classmethod
    def new(cls) -> HeaderBar: ...
    def pack_end(self, child: Widget) -> None: ...
    def pack_start(self, child: Widget) -> None: ...
    def remove(self, child: Widget) -> None: ...
    def set_decoration_layout(self, layout: typing.Optional[str] = None) -> None: ...
    def set_show_title_buttons(self, setting: bool) -> None: ...
    def set_title_widget(
        self, title_widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_use_native_controls(self, setting: bool) -> None: ...

class IMContext(GObject.Object):
    """
    :Constructors:

    ::

        IMContext(**properties)

    Object GtkIMContext

    Signals from GtkIMContext:
      preedit-start ()
      preedit-end ()
      preedit-changed ()
      commit (gchararray)
      retrieve-surrounding () -> gboolean
      delete-surrounding (gint, gint) -> gboolean

    Properties from GtkIMContext:
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        input_hints: InputHints
        input_purpose: InputPurpose

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(
        self, input_hints: InputHints = ..., input_purpose: InputPurpose = ...
    ) -> None: ...
    def activate_osk(self, event: typing.Optional[Gdk.Event] = None) -> bool: ...
    def delete_surrounding(self, offset: int, n_chars: int) -> bool: ...
    def do_activate_osk(self) -> None: ...
    def do_activate_osk_with_event(self, event: Gdk.Event) -> bool: ...
    def do_commit(self, str: str) -> None: ...
    def do_delete_surrounding(self, offset: int, n_chars: int) -> bool: ...
    def do_filter_keypress(self, event: Gdk.Event) -> bool: ...
    def do_focus_in(self) -> None: ...
    def do_focus_out(self) -> None: ...
    def do_get_preedit_string(self) -> typing.Tuple[str, Pango.AttrList, int]: ...
    def do_get_surrounding(self) -> typing.Tuple[bool, str, int]: ...
    def do_get_surrounding_with_selection(
        self,
    ) -> typing.Tuple[bool, str, int, int]: ...
    def do_preedit_changed(self) -> None: ...
    def do_preedit_end(self) -> None: ...
    def do_preedit_start(self) -> None: ...
    def do_reset(self) -> None: ...
    def do_retrieve_surrounding(self) -> bool: ...
    def do_set_client_widget(self, widget: typing.Optional[Widget] = None) -> None: ...
    def do_set_cursor_location(self, area: Gdk.Rectangle) -> None: ...
    def do_set_surrounding(self, text: str, len: int, cursor_index: int) -> None: ...
    def do_set_surrounding_with_selection(
        self, text: str, len: int, cursor_index: int, anchor_index: int
    ) -> None: ...
    def do_set_use_preedit(self, use_preedit: bool) -> None: ...
    def filter_key(
        self,
        press: bool,
        surface: Gdk.Surface,
        device: Gdk.Device,
        time: int,
        keycode: int,
        state: Gdk.ModifierType,
        group: int,
    ) -> bool: ...
    def filter_keypress(self, event: Gdk.Event) -> bool: ...
    def focus_in(self) -> None: ...
    def focus_out(self) -> None: ...
    def get_preedit_string(self) -> typing.Tuple[str, Pango.AttrList, int]: ...
    def get_surrounding(
        self,
    ) -> typing.Optional[typing.Tuple[str, int]]: ...  # CHECK Wrapped function
    def get_surrounding_with_selection(self) -> typing.Tuple[bool, str, int, int]: ...
    def reset(self) -> None: ...
    def set_client_widget(self, widget: typing.Optional[Widget] = None) -> None: ...
    def set_cursor_location(self, area: Gdk.Rectangle) -> None: ...
    def set_surrounding(self, text: str, len: int, cursor_index: int) -> None: ...
    def set_surrounding_with_selection(
        self, text: str, len: int, cursor_index: int, anchor_index: int
    ) -> None: ...
    def set_use_preedit(self, use_preedit: bool) -> None: ...

class IMContextClass(GObject.GPointer):
    """
    :Constructors:

    ::

        IMContextClass()
    """

    parent_class: GObject.ObjectClass = ...
    preedit_start: typing.Callable[[IMContext], None] = ...
    preedit_end: typing.Callable[[IMContext], None] = ...
    preedit_changed: typing.Callable[[IMContext], None] = ...
    commit: typing.Callable[[IMContext, str], None] = ...
    retrieve_surrounding: typing.Callable[[IMContext], bool] = ...
    delete_surrounding: typing.Callable[[IMContext, int, int], bool] = ...
    set_client_widget: typing.Callable[[IMContext, typing.Optional[Widget]], None] = ...
    get_preedit_string: typing.Callable[
        [IMContext], typing.Tuple[str, Pango.AttrList, int]
    ] = ...
    filter_keypress: typing.Callable[[IMContext, Gdk.Event], bool] = ...
    focus_in: typing.Callable[[IMContext], None] = ...
    focus_out: typing.Callable[[IMContext], None] = ...
    reset: typing.Callable[[IMContext], None] = ...
    set_cursor_location: typing.Callable[[IMContext, Gdk.Rectangle], None] = ...
    set_use_preedit: typing.Callable[[IMContext, bool], None] = ...
    set_surrounding: typing.Callable[[IMContext, str, int, int], None] = ...
    get_surrounding: typing.Callable[[IMContext], typing.Tuple[bool, str, int]] = ...
    set_surrounding_with_selection: typing.Callable[
        [IMContext, str, int, int, int], None
    ] = ...
    get_surrounding_with_selection: typing.Callable[
        [IMContext], typing.Tuple[bool, str, int, int]
    ] = ...
    activate_osk: typing.Callable[[IMContext], None] = ...
    activate_osk_with_event: typing.Callable[[IMContext, Gdk.Event], bool] = ...

class IMContextSimple(IMContext):
    """
    :Constructors:

    ::

        IMContextSimple(**properties)
        new() -> Gtk.IMContext

    Object GtkIMContextSimple

    Signals from GtkIMContext:
      preedit-start ()
      preedit-end ()
      preedit-changed ()
      commit (gchararray)
      retrieve-surrounding () -> gboolean
      delete-surrounding (gint, gint) -> gboolean

    Properties from GtkIMContext:
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints

    Signals from GObject:
      notify (GParam)
    """
    class Props(IMContext.Props):
        input_hints: InputHints
        input_purpose: InputPurpose

    props: Props = ...
    object: IMContext = ...
    priv: IMContextSimplePrivate = ...
    def __init__(
        self, input_hints: InputHints = ..., input_purpose: InputPurpose = ...
    ) -> None: ...
    def add_compose_file(self, compose_file: str) -> None: ...
    @classmethod
    def new(cls) -> IMContextSimple: ...

class IMContextSimpleClass(GObject.GPointer):
    """
    :Constructors:

    ::

        IMContextSimpleClass()
    """

    parent_class: IMContextClass = ...

class IMContextSimplePrivate(GObject.GPointer): ...

class IMMulticontext(IMContext):
    """
    :Constructors:

    ::

        IMMulticontext(**properties)
        new() -> Gtk.IMContext

    Object GtkIMMulticontext

    Signals from GtkIMContext:
      preedit-start ()
      preedit-end ()
      preedit-changed ()
      commit (gchararray)
      retrieve-surrounding () -> gboolean
      delete-surrounding (gint, gint) -> gboolean

    Properties from GtkIMContext:
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints

    Signals from GObject:
      notify (GParam)
    """
    class Props(IMContext.Props):
        input_hints: InputHints
        input_purpose: InputPurpose

    props: Props = ...
    object: IMContext = ...
    priv: IMMulticontextPrivate = ...
    def __init__(
        self, input_hints: InputHints = ..., input_purpose: InputPurpose = ...
    ) -> None: ...
    def get_context_id(self) -> str: ...
    @classmethod
    def new(cls) -> IMMulticontext: ...
    def set_context_id(self, context_id: typing.Optional[str] = None) -> None: ...

class IMMulticontextClass(GObject.GPointer):
    """
    :Constructors:

    ::

        IMMulticontextClass()
    """

    parent_class: IMContextClass = ...

class IMMulticontextPrivate(GObject.GPointer): ...

class IconPaintable(GObject.Object, Gdk.Paintable, SymbolicPaintable):
    """
    :Constructors:

    ::

        IconPaintable(**properties)
        new_for_file(file:Gio.File, size:int, scale:int) -> Gtk.IconPaintable

    Object GtkIconPaintable

    Properties from GtkIconPaintable:
      file -> GFile: file
      icon-name -> gchararray: icon-name
      is-symbolic -> gboolean: is-symbolic
      size -> gint: size
      scale -> gint: scale

    Signals from GdkPaintable:
      invalidate-contents ()
      invalidate-size ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        file: typing.Optional[Gio.File]
        icon_name: typing.Optional[str]
        is_symbolic: bool
        scale: int
        size: int

    props: Props = ...
    def __init__(
        self,
        file: Gio.File = ...,
        icon_name: str = ...,
        is_symbolic: bool = ...,
        scale: int = ...,
        size: int = ...,
    ) -> None: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_icon_name(self) -> typing.Optional[str]: ...
    def is_symbolic(self) -> bool: ...
    @classmethod
    def new_for_file(cls, file: Gio.File, size: int, scale: int) -> IconPaintable: ...

class IconPaintableClass(GObject.GPointer):
    """
    :Constructors:

    ::

        IconPaintableClass()
    """

    parent_class: GObject.ObjectClass = ...

class IconTheme(GObject.Object):
    """
    :Constructors:

    ::

        IconTheme(**properties)
        new() -> Gtk.IconTheme

    Object GtkIconTheme

    Signals from GtkIconTheme:
      changed ()

    Properties from GtkIconTheme:
      display -> GdkDisplay: display
      icon-names -> GStrv: icon-names
      search-path -> GStrv: search-path
      resource-path -> GStrv: resource-path
      theme-name -> gchararray: theme-name

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        display: typing.Optional[Gdk.Display]
        icon_names: list[str]
        resource_path: typing.Optional[list[str]]
        search_path: typing.Optional[list[str]]
        theme_name: str

    props: Props = ...
    def __init__(
        self,
        display: Gdk.Display = ...,
        resource_path: typing.Optional[typing.Sequence[str]] = ...,
        search_path: typing.Optional[typing.Sequence[str]] = ...,
        theme_name: typing.Optional[str] = ...,
    ) -> None: ...
    def add_resource_path(self, path: str) -> None: ...
    def add_search_path(self, path: str) -> None: ...
    def get_display(self) -> typing.Optional[Gdk.Display]: ...
    @staticmethod
    def get_for_display(display: Gdk.Display) -> IconTheme: ...
    def get_icon_names(self) -> list[str]: ...
    def get_icon_sizes(self, icon_name: str) -> list[int]: ...
    def get_resource_path(self) -> typing.Optional[list[str]]: ...
    def get_search_path(self) -> typing.Optional[list[str]]: ...
    def get_theme_name(self) -> str: ...
    def has_gicon(self, gicon: Gio.Icon) -> bool: ...
    def has_icon(self, icon_name: str) -> bool: ...
    def lookup_by_gicon(
        self,
        icon: Gio.Icon,
        size: int,
        scale: int,
        direction: TextDirection,
        flags: IconLookupFlags,
    ) -> IconPaintable: ...
    def lookup_icon(
        self,
        icon_name: str,
        fallbacks: typing.Optional[typing.Sequence[str]],
        size: int,
        scale: int,
        direction: TextDirection,
        flags: IconLookupFlags,
    ) -> IconPaintable: ...
    @classmethod
    def new(cls) -> IconTheme: ...
    def set_resource_path(
        self, path: typing.Optional[typing.Sequence[str]] = None
    ) -> None: ...
    def set_search_path(
        self, path: typing.Optional[typing.Sequence[str]] = None
    ) -> None: ...
    def set_theme_name(self, theme_name: typing.Optional[str] = None) -> None: ...

class IconView(Widget, Accessible, Buildable, CellLayout, ConstraintTarget, Scrollable):
    """
    :Constructors:

    ::

        IconView(**properties)
        new() -> Gtk.Widget
        new_with_area(area:Gtk.CellArea) -> Gtk.Widget
        new_with_model(model:Gtk.TreeModel) -> Gtk.Widget

    Object GtkIconView

    Signals from GtkIconView:
      move-cursor (GtkMovementStep, gint, gboolean, gboolean) -> gboolean
      select-all ()
      unselect-all ()
      item-activated (GtkTreePath)
      selection-changed ()
      select-cursor-item ()
      toggle-cursor-item ()
      activate-cursor-item () -> gboolean

    Properties from GtkIconView:
      pixbuf-column -> gint: pixbuf-column
      text-column -> gint: text-column
      markup-column -> gint: markup-column
      selection-mode -> GtkSelectionMode: selection-mode
      item-orientation -> GtkOrientation: item-orientation
      model -> GtkTreeModel: model
      columns -> gint: columns
      item-width -> gint: item-width
      spacing -> gint: spacing
      row-spacing -> gint: row-spacing
      column-spacing -> gint: column-spacing
      margin -> gint: margin
      reorderable -> gboolean: reorderable
      tooltip-column -> gint: tooltip-column
      item-padding -> gint: item-padding
      cell-area -> GtkCellArea: cell-area
      activate-on-single-click -> gboolean: activate-on-single-click

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activate_on_single_click: bool
        cell_area: CellArea
        column_spacing: int
        columns: int
        item_orientation: Orientation
        item_padding: int
        item_width: int
        margin: int
        markup_column: int
        model: typing.Optional[TreeModel]
        pixbuf_column: int
        reorderable: bool
        row_spacing: int
        selection_mode: SelectionMode
        spacing: int
        text_column: int
        tooltip_column: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    def __init__(
        self,
        activate_on_single_click: bool = ...,
        cell_area: CellArea = ...,
        column_spacing: int = ...,
        columns: int = ...,
        item_orientation: Orientation = ...,
        item_padding: int = ...,
        item_width: int = ...,
        margin: int = ...,
        markup_column: int = ...,
        model: typing.Optional[TreeModel] = ...,
        pixbuf_column: int = ...,
        reorderable: bool = ...,
        row_spacing: int = ...,
        selection_mode: SelectionMode = ...,
        spacing: int = ...,
        text_column: int = ...,
        tooltip_column: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def create_drag_icon(self, path: TreePath) -> typing.Optional[Gdk.Paintable]: ...
    def enable_model_drag_dest(
        self, formats: Gdk.ContentFormats, actions: Gdk.DragAction
    ) -> None: ...
    def enable_model_drag_source(
        self,
        start_button_mask: Gdk.ModifierType,
        formats: Gdk.ContentFormats,
        actions: Gdk.DragAction,
    ) -> None: ...
    def get_activate_on_single_click(self) -> bool: ...
    def get_cell_rect(
        self, path: TreePath, cell: typing.Optional[CellRenderer] = None
    ) -> typing.Tuple[bool, Gdk.Rectangle]: ...
    def get_column_spacing(self) -> int: ...
    def get_columns(self) -> int: ...
    def get_cursor(self) -> typing.Tuple[bool, TreePath, CellRenderer]: ...
    def get_dest_item_at_pos(
        self, drag_x: int, drag_y: int
    ) -> typing.Optional[
        typing.Tuple[TreePath, IconViewDropPosition]
    ]: ...  # CHECK Wrapped function
    def get_drag_dest_item(self) -> typing.Tuple[TreePath, IconViewDropPosition]: ...
    def get_item_at_pos(
        self, x: int, y: int
    ) -> typing.Optional[
        typing.Tuple[TreePath, CellRenderer]
    ]: ...  # CHECK Wrapped function
    def get_item_column(self, path: TreePath) -> int: ...
    def get_item_orientation(self) -> Orientation: ...
    def get_item_padding(self) -> int: ...
    def get_item_row(self, path: TreePath) -> int: ...
    def get_item_width(self) -> int: ...
    def get_margin(self) -> int: ...
    def get_markup_column(self) -> int: ...
    def get_model(self) -> typing.Optional[TreeModel]: ...
    def get_path_at_pos(self, x: int, y: int) -> typing.Optional[TreePath]: ...
    def get_pixbuf_column(self) -> int: ...
    def get_reorderable(self) -> bool: ...
    def get_row_spacing(self) -> int: ...
    def get_selected_items(self) -> list[TreePath]: ...
    def get_selection_mode(self) -> SelectionMode: ...
    def get_spacing(self) -> int: ...
    def get_text_column(self) -> int: ...
    def get_tooltip_column(self) -> int: ...
    def get_tooltip_context(
        self, x: int, y: int, keyboard_tip: bool
    ) -> typing.Tuple[bool, TreeModel, TreePath, TreeIter]: ...
    def get_visible_range(
        self,
    ) -> typing.Optional[
        typing.Tuple[TreePath, TreePath]
    ]: ...  # CHECK Wrapped function
    def item_activated(self, path: TreePath) -> None: ...
    @classmethod
    def new(cls) -> IconView: ...
    @classmethod
    def new_with_area(cls, area: CellArea) -> IconView: ...
    @classmethod
    def new_with_model(cls, model: TreeModel) -> IconView: ...
    def path_is_selected(self, path: TreePath) -> bool: ...
    def scroll_to_path(
        self, path: TreePath, use_align: bool, row_align: float, col_align: float
    ) -> None: ...
    def select_all(self) -> None: ...
    def select_path(self, path: TreePath) -> None: ...
    def selected_foreach(
        self, func: typing.Callable[..., None], *data: typing.Any
    ) -> None: ...
    def set_activate_on_single_click(self, single: bool) -> None: ...
    def set_column_spacing(self, column_spacing: int) -> None: ...
    def set_columns(self, columns: int) -> None: ...
    def set_cursor(
        self, path: TreePath, cell: typing.Optional[CellRenderer], start_editing: bool
    ) -> None: ...
    def set_drag_dest_item(
        self, path: typing.Optional[TreePath], pos: IconViewDropPosition
    ) -> None: ...
    def set_item_orientation(self, orientation: Orientation) -> None: ...
    def set_item_padding(self, item_padding: int) -> None: ...
    def set_item_width(self, item_width: int) -> None: ...
    def set_margin(self, margin: int) -> None: ...
    def set_markup_column(self, column: int) -> None: ...
    def set_model(self, model: typing.Optional[TreeModel] = None) -> None: ...
    def set_pixbuf_column(self, column: int) -> None: ...
    def set_reorderable(self, reorderable: bool) -> None: ...
    def set_row_spacing(self, row_spacing: int) -> None: ...
    def set_selection_mode(self, mode: SelectionMode) -> None: ...
    def set_spacing(self, spacing: int) -> None: ...
    def set_text_column(self, column: int) -> None: ...
    def set_tooltip_cell(
        self,
        tooltip: Tooltip,
        path: TreePath,
        cell: typing.Optional[CellRenderer] = None,
    ) -> None: ...
    def set_tooltip_column(self, column: int) -> None: ...
    def set_tooltip_item(self, tooltip: Tooltip, path: TreePath) -> None: ...
    def unselect_all(self) -> None: ...
    def unselect_path(self, path: TreePath) -> None: ...
    def unset_model_drag_dest(self) -> None: ...
    def unset_model_drag_source(self) -> None: ...

class Image(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Image(**properties)
        new() -> Gtk.Widget
        new_from_file(filename:str) -> Gtk.Widget
        new_from_gicon(icon:Gio.Icon) -> Gtk.Widget
        new_from_icon_name(icon_name:str=None) -> Gtk.Widget
        new_from_paintable(paintable:Gdk.Paintable=None) -> Gtk.Widget
        new_from_pixbuf(pixbuf:GdkPixbuf.Pixbuf=None) -> Gtk.Widget
        new_from_resource(resource_path:str) -> Gtk.Widget

    Object GtkImage

    Properties from GtkImage:
      paintable -> GdkPaintable: paintable
      file -> gchararray: file
      icon-size -> GtkIconSize: icon-size
      pixel-size -> gint: pixel-size
      icon-name -> gchararray: icon-name
      storage-type -> GtkImageType: storage-type
      gicon -> GIcon: gicon
      resource -> gchararray: resource
      use-fallback -> gboolean: use-fallback

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        file: str
        gicon: typing.Optional[Gio.Icon]
        icon_name: typing.Optional[str]
        icon_size: IconSize
        paintable: typing.Optional[Gdk.Paintable]
        pixel_size: int
        resource: str
        storage_type: ImageType
        use_fallback: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        file: str = ...,
        gicon: Gio.Icon = ...,
        icon_name: typing.Optional[str] = ...,
        icon_size: IconSize = ...,
        paintable: typing.Optional[Gdk.Paintable] = ...,
        pixel_size: int = ...,
        resource: str = ...,
        use_fallback: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def clear(self) -> None: ...
    def get_gicon(self) -> typing.Optional[Gio.Icon]: ...
    def get_icon_name(self) -> typing.Optional[str]: ...
    def get_icon_size(self) -> IconSize: ...
    def get_paintable(self) -> typing.Optional[Gdk.Paintable]: ...
    def get_pixel_size(self) -> int: ...
    def get_storage_type(self) -> ImageType: ...
    @classmethod
    def new(cls) -> Image: ...
    @classmethod
    def new_from_file(cls, filename: str) -> Image: ...
    @classmethod
    def new_from_gicon(cls, icon: Gio.Icon) -> Image: ...
    @classmethod
    def new_from_icon_name(cls, icon_name: typing.Optional[str] = None) -> Image: ...
    @classmethod
    def new_from_paintable(
        cls, paintable: typing.Optional[Gdk.Paintable] = None
    ) -> Image: ...
    @classmethod
    def new_from_pixbuf(
        cls, pixbuf: typing.Optional[GdkPixbuf.Pixbuf] = None
    ) -> Image: ...
    @classmethod
    def new_from_resource(cls, resource_path: str) -> Image: ...
    def set_from_file(self, filename: typing.Optional[str] = None) -> None: ...
    def set_from_gicon(self, icon: Gio.Icon) -> None: ...
    def set_from_icon_name(self, icon_name: typing.Optional[str] = None) -> None: ...
    def set_from_paintable(
        self, paintable: typing.Optional[Gdk.Paintable] = None
    ) -> None: ...
    def set_from_pixbuf(
        self, pixbuf: typing.Optional[GdkPixbuf.Pixbuf] = None
    ) -> None: ...
    def set_from_resource(self, resource_path: typing.Optional[str] = None) -> None: ...
    def set_icon_size(self, icon_size: IconSize) -> None: ...
    def set_pixel_size(self, pixel_size: int) -> None: ...

class InfoBar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        InfoBar(**properties)
        new() -> Gtk.Widget

    Object GtkInfoBar

    Signals from GtkInfoBar:
      response (gint)
      close ()

    Properties from GtkInfoBar:
      message-type -> GtkMessageType: message-type
      show-close-button -> gboolean: show-close-button
      revealed -> gboolean: revealed

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        message_type: MessageType
        revealed: bool
        show_close_button: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        message_type: MessageType = ...,
        revealed: bool = ...,
        show_close_button: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_action_widget(self, child: Widget, response_id: int) -> None: ...
    def add_button(self, button_text: str, response_id: int) -> Button: ...
    def add_child(self, widget: Widget) -> None: ...
    def get_message_type(self) -> MessageType: ...
    def get_revealed(self) -> bool: ...
    def get_show_close_button(self) -> bool: ...
    @classmethod
    def new(cls) -> InfoBar: ...
    def remove_action_widget(self, widget: Widget) -> None: ...
    def remove_child(self, widget: Widget) -> None: ...
    def response(self, response_id: int) -> None: ...
    def set_default_response(self, response_id: int) -> None: ...
    def set_message_type(self, message_type: MessageType) -> None: ...
    def set_response_sensitive(self, response_id: int, setting: bool) -> None: ...
    def set_revealed(self, revealed: bool) -> None: ...
    def set_show_close_button(self, setting: bool) -> None: ...

class Inscription(Widget, Accessible, AccessibleText, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Inscription(**properties)
        new(text:str=None) -> Gtk.Widget

    Object GtkInscription

    Properties from GtkInscription:
      attributes -> PangoAttrList: attributes
      markup -> gchararray: markup
      min-chars -> guint: min-chars
      min-lines -> guint: min-lines
      nat-chars -> guint: nat-chars
      nat-lines -> guint: nat-lines
      text -> gchararray: text
      text-overflow -> GtkInscriptionOverflow: text-overflow
      wrap-mode -> PangoWrapMode: wrap-mode
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        attributes: typing.Optional[Pango.AttrList]
        min_chars: int
        min_lines: int
        nat_chars: int
        nat_lines: int
        text: typing.Optional[str]
        text_overflow: InscriptionOverflow
        wrap_mode: Pango.WrapMode
        xalign: float
        yalign: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        markup: typing.Optional[str]

    props: Props = ...
    def __init__(
        self,
        attributes: typing.Optional[Pango.AttrList] = ...,
        markup: typing.Optional[str] = ...,
        min_chars: int = ...,
        min_lines: int = ...,
        nat_chars: int = ...,
        nat_lines: int = ...,
        text: typing.Optional[str] = ...,
        text_overflow: InscriptionOverflow = ...,
        wrap_mode: Pango.WrapMode = ...,
        xalign: float = ...,
        yalign: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_attributes(self) -> typing.Optional[Pango.AttrList]: ...
    def get_min_chars(self) -> int: ...
    def get_min_lines(self) -> int: ...
    def get_nat_chars(self) -> int: ...
    def get_nat_lines(self) -> int: ...
    def get_text(self) -> typing.Optional[str]: ...
    def get_text_overflow(self) -> InscriptionOverflow: ...
    def get_wrap_mode(self) -> Pango.WrapMode: ...
    def get_xalign(self) -> float: ...
    def get_yalign(self) -> float: ...
    @classmethod
    def new(cls, text: typing.Optional[str] = None) -> Inscription: ...
    def set_attributes(self, attrs: typing.Optional[Pango.AttrList] = None) -> None: ...
    def set_markup(self, markup: typing.Optional[str] = None) -> None: ...
    def set_min_chars(self, min_chars: int) -> None: ...
    def set_min_lines(self, min_lines: int) -> None: ...
    def set_nat_chars(self, nat_chars: int) -> None: ...
    def set_nat_lines(self, nat_lines: int) -> None: ...
    def set_text(self, text: typing.Optional[str] = None) -> None: ...
    def set_text_overflow(self, overflow: InscriptionOverflow) -> None: ...
    def set_wrap_mode(self, wrap_mode: Pango.WrapMode) -> None: ...
    def set_xalign(self, xalign: float) -> None: ...
    def set_yalign(self, yalign: float) -> None: ...

class InscriptionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        InscriptionClass()
    """

    parent_class: WidgetClass = ...

class KeyvalTrigger(ShortcutTrigger):
    """
    :Constructors:

    ::

        KeyvalTrigger(**properties)
        new(keyval:int, modifiers:Gdk.ModifierType) -> Gtk.ShortcutTrigger

    Object GtkKeyvalTrigger

    Properties from GtkKeyvalTrigger:
      keyval -> guint: keyval
      modifiers -> GdkModifierType: modifiers

    Signals from GObject:
      notify (GParam)
    """
    class Props(ShortcutTrigger.Props):
        keyval: int
        modifiers: Gdk.ModifierType

    props: Props = ...
    def __init__(
        self, keyval: int = ..., modifiers: Gdk.ModifierType = ...
    ) -> None: ...
    def get_keyval(self) -> int: ...
    def get_modifiers(self) -> Gdk.ModifierType: ...
    @classmethod
    def new(cls, keyval: int, modifiers: Gdk.ModifierType) -> KeyvalTrigger: ...

class KeyvalTriggerClass(GObject.GPointer): ...

class Label(Widget, Accessible, AccessibleText, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Label(**properties)
        new(str:str=None) -> Gtk.Widget
        new_with_mnemonic(str:str=None) -> Gtk.Widget

    Object GtkLabel

    Signals from GtkLabel:
      activate-link (gchararray) -> gboolean
      move-cursor (GtkMovementStep, gint, gboolean)
      copy-clipboard ()
      activate-current-link ()

    Properties from GtkLabel:
      label -> gchararray: label
      attributes -> PangoAttrList: attributes
      use-markup -> gboolean: use-markup
      use-underline -> gboolean: use-underline
      justify -> GtkJustification: justify
      wrap -> gboolean: wrap
      wrap-mode -> PangoWrapMode: wrap-mode
      natural-wrap-mode -> GtkNaturalWrapMode: natural-wrap-mode
      selectable -> gboolean: selectable
      mnemonic-keyval -> guint: mnemonic-keyval
      mnemonic-widget -> GtkWidget: mnemonic-widget
      ellipsize -> PangoEllipsizeMode: ellipsize
      width-chars -> gint: width-chars
      single-line-mode -> gboolean: single-line-mode
      max-width-chars -> gint: max-width-chars
      lines -> gint: lines
      xalign -> gfloat: xalign
      yalign -> gfloat: yalign
      extra-menu -> GMenuModel: extra-menu
      tabs -> PangoTabArray: tabs

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        attributes: typing.Optional[Pango.AttrList]
        ellipsize: Pango.EllipsizeMode
        extra_menu: typing.Optional[Gio.MenuModel]
        justify: Justification
        label: str
        lines: int
        max_width_chars: int
        mnemonic_keyval: int
        mnemonic_widget: typing.Optional[Widget]
        natural_wrap_mode: NaturalWrapMode
        selectable: bool
        single_line_mode: bool
        tabs: typing.Optional[Pango.TabArray]
        use_markup: bool
        use_underline: bool
        width_chars: int
        wrap: bool
        wrap_mode: Pango.WrapMode
        xalign: float
        yalign: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        attributes: typing.Optional[Pango.AttrList] = ...,
        ellipsize: Pango.EllipsizeMode = ...,
        extra_menu: typing.Optional[Gio.MenuModel] = ...,
        justify: Justification = ...,
        label: str = ...,
        lines: int = ...,
        max_width_chars: int = ...,
        mnemonic_widget: typing.Optional[Widget] = ...,
        natural_wrap_mode: NaturalWrapMode = ...,
        selectable: bool = ...,
        single_line_mode: bool = ...,
        tabs: typing.Optional[Pango.TabArray] = ...,
        use_markup: bool = ...,
        use_underline: bool = ...,
        width_chars: int = ...,
        wrap: bool = ...,
        wrap_mode: Pango.WrapMode = ...,
        xalign: float = ...,
        yalign: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_attributes(self) -> typing.Optional[Pango.AttrList]: ...
    def get_current_uri(self) -> typing.Optional[str]: ...
    def get_ellipsize(self) -> Pango.EllipsizeMode: ...
    def get_extra_menu(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_justify(self) -> Justification: ...
    def get_label(self) -> str: ...
    def get_layout(self) -> Pango.Layout: ...
    def get_layout_offsets(self) -> typing.Tuple[int, int]: ...
    def get_lines(self) -> int: ...
    def get_max_width_chars(self) -> int: ...
    def get_mnemonic_keyval(self) -> int: ...
    def get_mnemonic_widget(self) -> typing.Optional[Widget]: ...
    def get_natural_wrap_mode(self) -> NaturalWrapMode: ...
    def get_selectable(self) -> bool: ...
    def get_selection_bounds(self) -> typing.Tuple[bool, int, int]: ...
    def get_single_line_mode(self) -> bool: ...
    def get_tabs(self) -> typing.Optional[Pango.TabArray]: ...
    def get_text(self) -> str: ...
    def get_use_markup(self) -> bool: ...
    def get_use_underline(self) -> bool: ...
    def get_width_chars(self) -> int: ...
    def get_wrap(self) -> bool: ...
    def get_wrap_mode(self) -> Pango.WrapMode: ...
    def get_xalign(self) -> float: ...
    def get_yalign(self) -> float: ...
    @classmethod
    def new(cls, str: typing.Optional[str] = None) -> Label: ...
    @classmethod
    def new_with_mnemonic(cls, str: typing.Optional[str] = None) -> Label: ...
    def select_region(self, start_offset: int, end_offset: int) -> None: ...
    def set_attributes(self, attrs: typing.Optional[Pango.AttrList] = None) -> None: ...
    def set_ellipsize(self, mode: Pango.EllipsizeMode) -> None: ...
    def set_extra_menu(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def set_justify(self, jtype: Justification) -> None: ...
    def set_label(self, str: str) -> None: ...
    def set_lines(self, lines: int) -> None: ...
    def set_markup(self, str: str) -> None: ...
    def set_markup_with_mnemonic(self, str: str) -> None: ...
    def set_max_width_chars(self, n_chars: int) -> None: ...
    def set_mnemonic_widget(self, widget: typing.Optional[Widget] = None) -> None: ...
    def set_natural_wrap_mode(self, wrap_mode: NaturalWrapMode) -> None: ...
    def set_selectable(self, setting: bool) -> None: ...
    def set_single_line_mode(self, single_line_mode: bool) -> None: ...
    def set_tabs(self, tabs: typing.Optional[Pango.TabArray] = None) -> None: ...
    def set_text(self, str: str) -> None: ...
    def set_text_with_mnemonic(self, str: str) -> None: ...
    def set_use_markup(self, setting: bool) -> None: ...
    def set_use_underline(self, setting: bool) -> None: ...
    def set_width_chars(self, n_chars: int) -> None: ...
    def set_wrap(self, wrap: bool) -> None: ...
    def set_wrap_mode(self, wrap_mode: Pango.WrapMode) -> None: ...
    def set_xalign(self, xalign: float) -> None: ...
    def set_yalign(self, yalign: float) -> None: ...

class LayoutChild(GObject.Object):
    """
    :Constructors:

    ::

        LayoutChild(**properties)

    Object GtkLayoutChild

    Properties from GtkLayoutChild:
      layout-manager -> GtkLayoutManager: layout-manager
      child-widget -> GtkWidget: child-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        child_widget: Widget
        layout_manager: LayoutManager

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(
        self, child_widget: Widget = ..., layout_manager: LayoutManager = ...
    ) -> None: ...
    def get_child_widget(self) -> Widget: ...
    def get_layout_manager(self) -> LayoutManager: ...

class LayoutChildClass(GObject.GPointer):
    """
    :Constructors:

    ::

        LayoutChildClass()
    """

    parent_class: GObject.ObjectClass = ...

class LayoutManager(GObject.Object):
    """
    :Constructors:

    ::

        LayoutManager(**properties)

    Object GtkLayoutManager

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    def allocate(
        self, widget: Widget, width: int, height: int, baseline: int
    ) -> None: ...
    def do_allocate(
        self, widget: Widget, width: int, height: int, baseline: int
    ) -> None: ...
    def do_create_layout_child(
        self, widget: Widget, for_child: Widget
    ) -> LayoutChild: ...
    def do_get_request_mode(self, widget: Widget) -> SizeRequestMode: ...
    def do_measure(
        self, widget: Widget, orientation: Orientation, for_size: int
    ) -> typing.Tuple[int, int, int, int]: ...
    def do_root(self) -> None: ...
    def do_unroot(self) -> None: ...
    def get_layout_child(self, child: Widget) -> LayoutChild: ...
    def get_request_mode(self) -> SizeRequestMode: ...
    def get_widget(self) -> typing.Optional[Widget]: ...
    def layout_changed(self) -> None: ...
    def measure(
        self, widget: Widget, orientation: Orientation, for_size: int
    ) -> typing.Tuple[int, int, int, int]: ...

class LayoutManagerClass(GObject.GPointer):
    """
    :Constructors:

    ::

        LayoutManagerClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_request_mode: typing.Callable[[LayoutManager, Widget], SizeRequestMode] = ...
    measure: typing.Callable[
        [LayoutManager, Widget, Orientation, int], typing.Tuple[int, int, int, int]
    ] = ...
    allocate: typing.Callable[[LayoutManager, Widget, int, int, int], None] = ...
    layout_child_type: typing.Type[typing.Any] = ...
    create_layout_child: typing.Callable[
        [LayoutManager, Widget, Widget], LayoutChild
    ] = ...
    root: typing.Callable[[LayoutManager], None] = ...
    unroot: typing.Callable[[LayoutManager], None] = ...

class LevelBar(
    Widget, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        LevelBar(**properties)
        new() -> Gtk.Widget
        new_for_interval(min_value:float, max_value:float) -> Gtk.Widget

    Object GtkLevelBar

    Signals from GtkLevelBar:
      offset-changed (gchararray)

    Properties from GtkLevelBar:
      value -> gdouble: value
      min-value -> gdouble: min-value
      max-value -> gdouble: max-value
      mode -> GtkLevelBarMode: mode
      inverted -> gboolean: inverted

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        inverted: bool
        max_value: float
        min_value: float
        mode: LevelBarMode
        value: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        inverted: bool = ...,
        max_value: float = ...,
        min_value: float = ...,
        mode: LevelBarMode = ...,
        value: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def add_offset_value(self, name: str, value: float) -> None: ...
    def get_inverted(self) -> bool: ...
    def get_max_value(self) -> float: ...
    def get_min_value(self) -> float: ...
    def get_mode(self) -> LevelBarMode: ...
    def get_offset_value(
        self, name: typing.Optional[str] = None
    ) -> typing.Tuple[bool, float]: ...
    def get_value(self) -> float: ...
    @classmethod
    def new(cls) -> LevelBar: ...
    @classmethod
    def new_for_interval(cls, min_value: float, max_value: float) -> LevelBar: ...
    def remove_offset_value(self, name: typing.Optional[str] = None) -> None: ...
    def set_inverted(self, inverted: bool) -> None: ...
    def set_max_value(self, value: float) -> None: ...
    def set_min_value(self, value: float) -> None: ...
    def set_mode(self, mode: LevelBarMode) -> None: ...
    def set_value(self, value: float) -> None: ...

class LinkButton(Button, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        LinkButton(**properties)
        new(uri:str) -> Gtk.Widget
        new_with_label(uri:str, label:str=None) -> Gtk.Widget

    Object GtkLinkButton

    Signals from GtkLinkButton:
      activate-link () -> gboolean

    Properties from GtkLinkButton:
      uri -> gchararray: uri
      visited -> gboolean: visited

    Signals from GtkButton:
      activate ()
      clicked ()

    Properties from GtkButton:
      label -> gchararray: label
      has-frame -> gboolean: has-frame
      use-underline -> gboolean: use-underline
      icon-name -> gchararray: icon-name
      child -> GtkWidget: child
      can-shrink -> gboolean: can-shrink

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Button.Props):
        uri: str
        visited: bool
        can_shrink: bool
        child: typing.Optional[Widget]
        has_frame: bool
        icon_name: typing.Optional[str]
        label: typing.Optional[str]
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant

    props: Props = ...
    def __init__(
        self,
        uri: str = ...,
        visited: bool = ...,
        can_shrink: bool = ...,
        child: typing.Optional[Widget] = ...,
        has_frame: bool = ...,
        icon_name: str = ...,
        label: str = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def get_uri(self) -> str: ...
    def get_visited(self) -> bool: ...
    @classmethod
    def new(cls, uri: str) -> LinkButton: ...
    @classmethod
    def new_with_label(
        cls, uri: str, label: typing.Optional[str] = None
    ) -> LinkButton: ...
    def set_uri(self, uri: str) -> None: ...
    def set_visited(self, visited: bool) -> None: ...

class ListBase(Widget, Accessible, Buildable, ConstraintTarget, Orientable, Scrollable):
    """
    :Constructors:

    ::

        ListBase(**properties)

    Object GtkListBase

    Properties from GtkListBase:
      orientation -> GtkOrientation: orientation

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        orientation: Orientation
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    def __init__(
        self,
        orientation: Orientation = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...

class ListBaseClass(GObject.GPointer): ...

class ListBox(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ListBox(**properties)
        new() -> Gtk.Widget

    Object GtkListBox

    Signals from GtkListBox:
      move-cursor (GtkMovementStep, gint, gboolean, gboolean)
      select-all ()
      unselect-all ()
      row-selected (GtkListBoxRow)
      selected-rows-changed ()
      row-activated (GtkListBoxRow)
      activate-cursor-row ()
      toggle-cursor-row ()

    Properties from GtkListBox:
      selection-mode -> GtkSelectionMode: selection-mode
      activate-on-single-click -> gboolean: activate-on-single-click
      accept-unpaired-release -> gboolean: accept-unpaired-release
      show-separators -> gboolean: show-separators
      tab-behavior -> GtkListTabBehavior: tab-behavior

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        accept_unpaired_release: bool
        activate_on_single_click: bool
        selection_mode: SelectionMode
        show_separators: bool
        tab_behavior: ListTabBehavior
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        accept_unpaired_release: bool = ...,
        activate_on_single_click: bool = ...,
        selection_mode: SelectionMode = ...,
        show_separators: bool = ...,
        tab_behavior: ListTabBehavior = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def append(self, child: Widget) -> None: ...
    # override
    def bind_model(
        self,
        model: typing.Optional[Gio.ListModel[typing.Any]] = None,
        create_widget_func: typing.Optional[typing.Callable[..., Widget]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def drag_highlight_row(self, row: ListBoxRow) -> None: ...
    def drag_unhighlight_row(self) -> None: ...
    def get_activate_on_single_click(self) -> bool: ...
    def get_adjustment(self) -> typing.Optional[Adjustment]: ...
    def get_row_at_index(self, index_: int) -> typing.Optional[ListBoxRow]: ...
    def get_row_at_y(self, y: int) -> typing.Optional[ListBoxRow]: ...
    def get_selected_row(self) -> typing.Optional[ListBoxRow]: ...
    def get_selected_rows(self) -> list[ListBoxRow]: ...
    def get_selection_mode(self) -> SelectionMode: ...
    def get_show_separators(self) -> bool: ...
    def get_tab_behavior(self) -> ListTabBehavior: ...
    def insert(self, child: Widget, position: int) -> None: ...
    def invalidate_filter(self) -> None: ...
    def invalidate_headers(self) -> None: ...
    def invalidate_sort(self) -> None: ...
    @classmethod
    def new(cls) -> ListBox: ...
    def prepend(self, child: Widget) -> None: ...
    def remove(self, child: Widget) -> None: ...
    def remove_all(self) -> None: ...
    def select_all(self) -> None: ...
    def select_row(self, row: typing.Optional[ListBoxRow] = None) -> None: ...
    def selected_foreach(
        self, func: typing.Callable[..., None], *data: typing.Any
    ) -> None: ...
    def set_activate_on_single_click(self, single: bool) -> None: ...
    def set_adjustment(
        self, adjustment: typing.Optional[Adjustment] = None
    ) -> None: ...
    def set_filter_func(
        self,
        filter_func: typing.Optional[typing.Callable[..., bool]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_header_func(
        self,
        update_header: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_placeholder(self, placeholder: typing.Optional[Widget] = None) -> None: ...
    def set_selection_mode(self, mode: SelectionMode) -> None: ...
    def set_show_separators(self, show_separators: bool) -> None: ...
    def set_sort_func(
        self,
        sort_func: typing.Optional[typing.Callable[..., int]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_tab_behavior(self, behavior: ListTabBehavior) -> None: ...
    def unselect_all(self) -> None: ...
    def unselect_row(self, row: ListBoxRow) -> None: ...

class ListBoxRow(Widget, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ListBoxRow(**properties)
        new() -> Gtk.Widget

    Object GtkListBoxRow

    Signals from GtkListBoxRow:
      activate ()

    Properties from GtkListBoxRow:
      activatable -> gboolean: activatable
      selectable -> gboolean: selectable
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activatable: bool
        child: typing.Optional[Widget]
        selectable: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        activatable: bool = ...,
        child: typing.Optional[Widget] = ...,
        selectable: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def changed(self) -> None: ...
    def do_activate(self) -> None: ...
    def get_activatable(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_header(self) -> typing.Optional[Widget]: ...
    def get_index(self) -> int: ...
    def get_selectable(self) -> bool: ...
    def is_selected(self) -> bool: ...
    @classmethod
    def new(cls) -> ListBoxRow: ...
    def set_activatable(self, activatable: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_header(self, header: typing.Optional[Widget] = None) -> None: ...
    def set_selectable(self, selectable: bool) -> None: ...

class ListBoxRowClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ListBoxRowClass()
    """

    parent_class: WidgetClass = ...
    activate: typing.Callable[[ListBoxRow], None] = ...
    padding: list[None] = ...

class ListHeader(GObject.Object):
    """
    :Constructors:

    ::

        ListHeader(**properties)

    Object GtkListHeader

    Properties from GtkListHeader:
      child -> GtkWidget: child
      end -> guint: end
      item -> GObject: item
      n-items -> guint: n-items
      start -> guint: start

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        child: typing.Optional[Widget]
        end: int
        item: typing.Optional[GObject.Object]
        n_items: int
        start: int

    props: Props = ...
    def __init__(self, child: typing.Optional[Widget] = ...) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_end(self) -> int: ...
    def get_item(self) -> typing.Optional[GObject.Object]: ...
    def get_n_items(self) -> int: ...
    def get_start(self) -> int: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...

class ListHeaderClass(GObject.GPointer): ...

class ListItem(GObject.Object):
    """
    :Constructors:

    ::

        ListItem(**properties)

    Object GtkListItem

    Properties from GtkListItem:
      accessible-description -> gchararray: accessible-description
      accessible-label -> gchararray: accessible-label
      activatable -> gboolean: activatable
      child -> GtkWidget: child
      focusable -> gboolean: focusable
      item -> GObject: item
      position -> guint: position
      selectable -> gboolean: selectable
      selected -> gboolean: selected

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        accessible_description: str
        accessible_label: str
        activatable: bool
        child: typing.Optional[Widget]
        focusable: bool
        item: typing.Optional[GObject.Object]
        position: int
        selectable: bool
        selected: bool

    props: Props = ...
    def __init__(
        self,
        accessible_description: str = ...,
        accessible_label: str = ...,
        activatable: bool = ...,
        child: typing.Optional[Widget] = ...,
        focusable: bool = ...,
        selectable: bool = ...,
    ) -> None: ...
    def get_accessible_description(self) -> str: ...
    def get_accessible_label(self) -> str: ...
    def get_activatable(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_focusable(self) -> bool: ...
    def get_item(self) -> typing.Optional[GObject.Object]: ...
    def get_position(self) -> int: ...
    def get_selectable(self) -> bool: ...
    def get_selected(self) -> bool: ...
    def set_accessible_description(self, description: str) -> None: ...
    def set_accessible_label(self, label: str) -> None: ...
    def set_activatable(self, activatable: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_focusable(self, focusable: bool) -> None: ...
    def set_selectable(self, selectable: bool) -> None: ...

class ListItemClass(GObject.GPointer): ...
class ListItemFactory(GObject.Object): ...
class ListItemFactoryClass(GObject.GPointer): ...

# override
class ListStore(
    GObject.Object, Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
):
    """
    :Constructors:

    ::

        ListStore(**properties)
        new(types:list) -> Gtk.ListStore

    Object GtkListStore

    Signals from GtkTreeModel:
      row-changed (GtkTreePath, GtkTreeIter)
      row-inserted (GtkTreePath, GtkTreeIter)
      row-has-child-toggled (GtkTreePath, GtkTreeIter)
      row-deleted (GtkTreePath)
      rows-reordered (GtkTreePath, GtkTreeIter, gpointer)

    Signals from GtkTreeSortable:
      sort-column-changed ()

    Signals from GObject:
      notify (GParam)
    """

    parent: GObject.Object = ...
    priv: ListStorePrivate = ...

    def __init__(self, *args: typing.Any) -> None: ...
    def append(
        self,
        row: typing.Union[list[typing.Any], typing.Tuple[typing.Any, ...], None] = None,
    ) -> TreeIter: ...
    def clear(self) -> None: ...
    def insert(
        self,
        position: int,
        row: typing.Union[list[typing.Any], typing.Tuple[typing.Any, ...], None] = None,
    ) -> TreeIter: ...
    def insert_after(
        self,
        sibling: TreeIter,
        row: typing.Union[list[typing.Any], typing.Tuple[typing.Any, ...], None] = None,
    ) -> TreeIter: ...
    def insert_before(
        self,
        sibling: TreeIter,
        row: typing.Union[list[typing.Any], typing.Tuple[typing.Any, ...], None] = None,
    ) -> TreeIter: ...
    def insert_with_values(
        self,
        position: int,
        columns: typing.Sequence[int],
        values: typing.Sequence[typing.Any],
    ) -> TreeIter: ...
    def insert_with_valuesv(
        self,
        position: int,
        columns: typing.Sequence[int],
        values: typing.Sequence[typing.Any],
    ) -> TreeIter: ...
    def iter_is_valid(self, iter: TreeIter) -> bool: ...
    def move_after(
        self, iter: TreeIter, position: typing.Optional[TreeIter] = None
    ) -> None: ...
    def move_before(
        self, iter: TreeIter, position: typing.Optional[TreeIter] = None
    ) -> None: ...
    @classmethod
    def new(cls, types: typing.Sequence[typing.Type[typing.Any]]) -> ListStore: ...
    def prepend(
        self,
        row: typing.Union[list[typing.Any], typing.Tuple[typing.Any, ...], None] = None,
    ) -> TreeIter: ...
    def remove(self, iter: TreeIter) -> bool: ...
    def reorder(self, new_order: typing.Sequence[int]) -> None: ...
    def set(self, treeiter: TreeIter, *args: dict[int, typing.Any]) -> None: ...
    def set_column_types(
        self, types: typing.Sequence[typing.Type[typing.Any]]
    ) -> None: ...
    def set_value(self, treeiter: TreeIter, column: int, value: typing.Any) -> None: ...
    def swap(self, a: TreeIter, b: TreeIter) -> None: ...

class ListStoreClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ListStoreClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class ListStorePrivate(GObject.GPointer): ...

class ListView(
    ListBase, Accessible, Buildable, ConstraintTarget, Orientable, Scrollable
):
    """
    :Constructors:

    ::

        ListView(**properties)
        new(model:Gtk.SelectionModel=None, factory:Gtk.ListItemFactory=None) -> Gtk.Widget

    Object GtkListView

    Signals from GtkListView:
      activate (guint)

    Properties from GtkListView:
      enable-rubberband -> gboolean: enable-rubberband
      factory -> GtkListItemFactory: factory
      header-factory -> GtkListItemFactory: header-factory
      model -> GtkSelectionModel: model
      show-separators -> gboolean: show-separators
      single-click-activate -> gboolean: single-click-activate
      tab-behavior -> GtkListTabBehavior: tab-behavior

    Properties from GtkListBase:
      orientation -> GtkOrientation: orientation

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(ListBase.Props):
        enable_rubberband: bool
        factory: typing.Optional[ListItemFactory]
        header_factory: typing.Optional[ListItemFactory]
        model: typing.Optional[SelectionModel]
        show_separators: bool
        single_click_activate: bool
        tab_behavior: ListTabBehavior
        orientation: Orientation
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    def __init__(
        self,
        enable_rubberband: bool = ...,
        factory: typing.Optional[ListItemFactory] = ...,
        header_factory: typing.Optional[ListItemFactory] = ...,
        model: typing.Optional[SelectionModel] = ...,
        show_separators: bool = ...,
        single_click_activate: bool = ...,
        tab_behavior: ListTabBehavior = ...,
        orientation: Orientation = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def get_enable_rubberband(self) -> bool: ...
    def get_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_header_factory(self) -> typing.Optional[ListItemFactory]: ...
    def get_model(self) -> typing.Optional[SelectionModel]: ...
    def get_show_separators(self) -> bool: ...
    def get_single_click_activate(self) -> bool: ...
    def get_tab_behavior(self) -> ListTabBehavior: ...
    @classmethod
    def new(
        cls,
        model: typing.Optional[SelectionModel] = None,
        factory: typing.Optional[ListItemFactory] = None,
    ) -> ListView: ...
    def scroll_to(
        self,
        pos: int,
        flags: ListScrollFlags,
        scroll: typing.Optional[ScrollInfo] = None,
    ) -> None: ...
    def set_enable_rubberband(self, enable_rubberband: bool) -> None: ...
    def set_factory(self, factory: typing.Optional[ListItemFactory] = None) -> None: ...
    def set_header_factory(
        self, factory: typing.Optional[ListItemFactory] = None
    ) -> None: ...
    def set_model(self, model: typing.Optional[SelectionModel] = None) -> None: ...
    def set_show_separators(self, show_separators: bool) -> None: ...
    def set_single_click_activate(self, single_click_activate: bool) -> None: ...
    def set_tab_behavior(self, tab_behavior: ListTabBehavior) -> None: ...

class ListViewClass(GObject.GPointer): ...

class LockButton(Button, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        LockButton(**properties)
        new(permission:Gio.Permission=None) -> Gtk.Widget

    Object GtkLockButton

    Properties from GtkLockButton:
      permission -> GPermission: permission
      text-lock -> gchararray: text-lock
      text-unlock -> gchararray: text-unlock
      tooltip-lock -> gchararray: tooltip-lock
      tooltip-unlock -> gchararray: tooltip-unlock
      tooltip-not-authorized -> gchararray: tooltip-not-authorized

    Signals from GtkButton:
      activate ()
      clicked ()

    Properties from GtkButton:
      label -> gchararray: label
      has-frame -> gboolean: has-frame
      use-underline -> gboolean: use-underline
      icon-name -> gchararray: icon-name
      child -> GtkWidget: child
      can-shrink -> gboolean: can-shrink

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Button.Props):
        permission: typing.Optional[Gio.Permission]
        text_lock: str
        text_unlock: str
        tooltip_lock: str
        tooltip_not_authorized: str
        tooltip_unlock: str
        can_shrink: bool
        child: typing.Optional[Widget]
        has_frame: bool
        icon_name: typing.Optional[str]
        label: typing.Optional[str]
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant

    props: Props = ...
    def __init__(
        self,
        permission: typing.Optional[Gio.Permission] = ...,
        text_lock: str = ...,
        text_unlock: str = ...,
        tooltip_lock: str = ...,
        tooltip_not_authorized: str = ...,
        tooltip_unlock: str = ...,
        can_shrink: bool = ...,
        child: typing.Optional[Widget] = ...,
        has_frame: bool = ...,
        icon_name: str = ...,
        label: str = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def get_permission(self) -> typing.Optional[Gio.Permission]: ...
    @classmethod
    def new(cls, permission: typing.Optional[Gio.Permission] = None) -> LockButton: ...
    def set_permission(
        self, permission: typing.Optional[Gio.Permission] = None
    ) -> None: ...

# override
class MapListModel(GObject.Object, Gio.ListModel[typing.Any], SectionModel):
    """
    :Constructors:

    ::

        MapListModel(**properties)
        new(model:Gio.ListModel=None, map_func:Gtk.MapListModelMapFunc=None, user_data=None) -> Gtk.MapListModel

    Object GtkMapListModel

    Properties from GtkMapListModel:
      has-map -> gboolean: has-map
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        has_map: bool
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel]
        n_items: int

    props: Props = ...
    def __init__(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = ...
    ) -> None: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def has_map(self) -> bool: ...
    @classmethod
    def new(
        cls,
        model: typing.Optional[Gio.ListModel[typing.Any]] = None,
        map_func: typing.Optional[typing.Callable[..., GObject.Object]] = None,
        *user_data: typing.Any,
    ) -> MapListModel: ...
    def set_map_func(
        self,
        map_func: typing.Optional[typing.Callable[..., GObject.Object]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...

class MapListModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MapListModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class MediaControls(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        MediaControls(**properties)
        new(stream:Gtk.MediaStream=None) -> Gtk.Widget

    Object GtkMediaControls

    Properties from GtkMediaControls:
      media-stream -> GtkMediaStream: media-stream

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        media_stream: typing.Optional[MediaStream]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        media_stream: typing.Optional[MediaStream] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_media_stream(self) -> typing.Optional[MediaStream]: ...
    @classmethod
    def new(cls, stream: typing.Optional[MediaStream] = None) -> MediaControls: ...
    def set_media_stream(self, stream: typing.Optional[MediaStream] = None) -> None: ...

class MediaControlsClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MediaControlsClass()
    """

    parent_class: WidgetClass = ...

class MediaFile(MediaStream, Gdk.Paintable):
    """
    :Constructors:

    ::

        MediaFile(**properties)
        new() -> Gtk.MediaFile
        new_for_file(file:Gio.File) -> Gtk.MediaFile
        new_for_filename(filename:str) -> Gtk.MediaFile
        new_for_input_stream(stream:Gio.InputStream) -> Gtk.MediaFile
        new_for_resource(resource_path:str) -> Gtk.MediaFile

    Object GtkMediaFile

    Properties from GtkMediaFile:
      file -> GFile: file
      input-stream -> GInputStream: input-stream

    Signals from GdkPaintable:
      invalidate-contents ()
      invalidate-size ()

    Properties from GtkMediaStream:
      prepared -> gboolean: prepared
      error -> GError: error
      has-audio -> gboolean: has-audio
      has-video -> gboolean: has-video
      playing -> gboolean: playing
      ended -> gboolean: ended
      timestamp -> gint64: timestamp
      duration -> gint64: duration
      seekable -> gboolean: seekable
      seeking -> gboolean: seeking
      loop -> gboolean: loop
      muted -> gboolean: muted
      volume -> gdouble: volume

    Signals from GdkPaintable:
      invalidate-contents ()
      invalidate-size ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(MediaStream.Props):
        file: typing.Optional[Gio.File]
        input_stream: typing.Optional[Gio.InputStream]
        duration: int
        ended: bool
        error: typing.Optional[GLib.Error]
        has_audio: bool
        has_video: bool
        loop: bool
        muted: bool
        playing: bool
        prepared: bool
        seekable: bool
        seeking: bool
        timestamp: int
        volume: float

    props: Props = ...
    parent_instance: MediaStream = ...
    def __init__(
        self,
        file: typing.Optional[Gio.File] = ...,
        input_stream: typing.Optional[Gio.InputStream] = ...,
        loop: bool = ...,
        muted: bool = ...,
        playing: bool = ...,
        volume: float = ...,
    ) -> None: ...
    def clear(self) -> None: ...
    def do_close(self) -> None: ...
    def do_open(self) -> None: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_input_stream(self) -> typing.Optional[Gio.InputStream]: ...
    @classmethod
    def new(cls) -> MediaFile: ...
    @classmethod
    def new_for_file(cls, file: Gio.File) -> MediaFile: ...
    @classmethod
    def new_for_filename(cls, filename: str) -> MediaFile: ...
    @classmethod
    def new_for_input_stream(cls, stream: Gio.InputStream) -> MediaFile: ...
    @classmethod
    def new_for_resource(cls, resource_path: str) -> MediaFile: ...
    def set_file(self, file: typing.Optional[Gio.File] = None) -> None: ...
    def set_filename(self, filename: typing.Optional[str] = None) -> None: ...
    def set_input_stream(
        self, stream: typing.Optional[Gio.InputStream] = None
    ) -> None: ...
    def set_resource(self, resource_path: typing.Optional[str] = None) -> None: ...

class MediaFileClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MediaFileClass()
    """

    parent_class: MediaStreamClass = ...
    open: typing.Callable[[MediaFile], None] = ...
    close: typing.Callable[[MediaFile], None] = ...

class MediaStream(GObject.Object, Gdk.Paintable):
    """
    :Constructors:

    ::

        MediaStream(**properties)

    Object GtkMediaStream

    Properties from GtkMediaStream:
      prepared -> gboolean: prepared
      error -> GError: error
      has-audio -> gboolean: has-audio
      has-video -> gboolean: has-video
      playing -> gboolean: playing
      ended -> gboolean: ended
      timestamp -> gint64: timestamp
      duration -> gint64: duration
      seekable -> gboolean: seekable
      seeking -> gboolean: seeking
      loop -> gboolean: loop
      muted -> gboolean: muted
      volume -> gdouble: volume

    Signals from GdkPaintable:
      invalidate-contents ()
      invalidate-size ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        duration: int
        ended: bool
        error: typing.Optional[GLib.Error]
        has_audio: bool
        has_video: bool
        loop: bool
        muted: bool
        playing: bool
        prepared: bool
        seekable: bool
        seeking: bool
        timestamp: int
        volume: float

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(
        self,
        loop: bool = ...,
        muted: bool = ...,
        playing: bool = ...,
        volume: float = ...,
    ) -> None: ...
    def do_pause(self) -> None: ...
    def do_play(self) -> bool: ...
    def do_realize(self, surface: Gdk.Surface) -> None: ...
    def do_seek(self, timestamp: int) -> None: ...
    def do_unrealize(self, surface: Gdk.Surface) -> None: ...
    def do_update_audio(self, muted: bool, volume: float) -> None: ...
    def gerror(self, error: GLib.Error) -> None: ...
    def get_duration(self) -> int: ...
    def get_ended(self) -> bool: ...
    def get_error(self) -> typing.Optional[GLib.Error]: ...
    def get_loop(self) -> bool: ...
    def get_muted(self) -> bool: ...
    def get_playing(self) -> bool: ...
    def get_timestamp(self) -> int: ...
    def get_volume(self) -> float: ...
    def has_audio(self) -> bool: ...
    def has_video(self) -> bool: ...
    def is_prepared(self) -> bool: ...
    def is_seekable(self) -> bool: ...
    def is_seeking(self) -> bool: ...
    def pause(self) -> None: ...
    def play(self) -> None: ...
    def realize(self, surface: Gdk.Surface) -> None: ...
    def seek(self, timestamp: int) -> None: ...
    def seek_failed(self) -> None: ...
    def seek_success(self) -> None: ...
    def set_loop(self, loop: bool) -> None: ...
    def set_muted(self, muted: bool) -> None: ...
    def set_playing(self, playing: bool) -> None: ...
    def set_volume(self, volume: float) -> None: ...
    def stream_ended(self) -> None: ...
    def stream_prepared(
        self, has_audio: bool, has_video: bool, seekable: bool, duration: int
    ) -> None: ...
    def stream_unprepared(self) -> None: ...
    def unrealize(self, surface: Gdk.Surface) -> None: ...
    def update(self, timestamp: int) -> None: ...

class MediaStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MediaStreamClass()
    """

    parent_class: GObject.ObjectClass = ...
    play: typing.Callable[[MediaStream], bool] = ...
    pause: typing.Callable[[MediaStream], None] = ...
    seek: typing.Callable[[MediaStream, int], None] = ...
    update_audio: typing.Callable[[MediaStream, bool, float], None] = ...
    realize: typing.Callable[[MediaStream, Gdk.Surface], None] = ...
    unrealize: typing.Callable[[MediaStream, Gdk.Surface], None] = ...

class MenuButton(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        MenuButton(**properties)
        new() -> Gtk.Widget

    Object GtkMenuButton

    Signals from GtkMenuButton:
      activate ()

    Properties from GtkMenuButton:
      menu-model -> GMenuModel: menu-model
      direction -> GtkArrowType: direction
      popover -> GtkPopover: popover
      icon-name -> gchararray: icon-name
      always-show-arrow -> gboolean: always-show-arrow
      label -> gchararray: label
      use-underline -> gboolean: use-underline
      has-frame -> gboolean: has-frame
      primary -> gboolean: primary
      child -> GtkWidget: child
      active -> gboolean: active
      can-shrink -> gboolean: can-shrink

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        active: bool
        always_show_arrow: bool
        can_shrink: bool
        child: typing.Optional[Widget]
        direction: ArrowType
        has_frame: bool
        icon_name: typing.Optional[str]
        label: typing.Optional[str]
        menu_model: typing.Optional[Gio.MenuModel]
        popover: typing.Optional[Popover]
        primary: bool
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        active: bool = ...,
        always_show_arrow: bool = ...,
        can_shrink: bool = ...,
        child: typing.Optional[Widget] = ...,
        direction: ArrowType = ...,
        has_frame: bool = ...,
        icon_name: str = ...,
        label: str = ...,
        menu_model: typing.Optional[Gio.MenuModel] = ...,
        popover: typing.Optional[Popover] = ...,
        primary: bool = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_active(self) -> bool: ...
    def get_always_show_arrow(self) -> bool: ...
    def get_can_shrink(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_direction(self) -> ArrowType: ...
    def get_has_frame(self) -> bool: ...
    def get_icon_name(self) -> typing.Optional[str]: ...
    def get_label(self) -> typing.Optional[str]: ...
    def get_menu_model(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_popover(self) -> typing.Optional[Popover]: ...
    def get_primary(self) -> bool: ...
    def get_use_underline(self) -> bool: ...
    @classmethod
    def new(cls) -> MenuButton: ...
    def popdown(self) -> None: ...
    def popup(self) -> None: ...
    def set_active(self, active: bool) -> None: ...
    def set_always_show_arrow(self, always_show_arrow: bool) -> None: ...
    def set_can_shrink(self, can_shrink: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_create_popup_func(
        self,
        func: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_direction(self, direction: ArrowType) -> None: ...
    def set_has_frame(self, has_frame: bool) -> None: ...
    def set_icon_name(self, icon_name: str) -> None: ...
    def set_label(self, label: str) -> None: ...
    def set_menu_model(
        self, menu_model: typing.Optional[Gio.MenuModel] = None
    ) -> None: ...
    def set_popover(self, popover: typing.Optional[Popover] = None) -> None: ...
    def set_primary(self, primary: bool) -> None: ...
    def set_use_underline(self, use_underline: bool) -> None: ...

class MessageDialog(
    Dialog, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        MessageDialog(**properties)

    Object GtkMessageDialog

    Properties from GtkMessageDialog:
      message-type -> GtkMessageType: message-type
      buttons -> GtkButtonsType: buttons
      text -> gchararray: text
      use-markup -> gboolean: use-markup
      secondary-text -> gchararray: secondary-text
      secondary-use-markup -> gboolean: secondary-use-markup
      message-area -> GtkWidget: message-area

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Dialog.Props):
        message_area: Widget
        message_type: MessageType
        secondary_text: str
        secondary_use_markup: bool
        text: str
        use_markup: bool
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        buttons: ButtonsType
        startup_id: str

    props: Props = ...
    parent_instance: Dialog = ...
    def __init__(
        self,
        buttons: ButtonsType = ...,
        message_type: MessageType = ...,
        secondary_text: str = ...,
        secondary_use_markup: bool = ...,
        text: str = ...,
        use_markup: bool = ...,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_message_area(self) -> Widget: ...
    def set_markup(self, str: str) -> None: ...

class MessageDialogClass(GObject.GPointer): ...

class MnemonicAction(ShortcutAction):
    """
    :Constructors:

    ::

        MnemonicAction(**properties)

    Object GtkMnemonicAction

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get() -> MnemonicAction: ...

class MnemonicActionClass(GObject.GPointer): ...

class MnemonicTrigger(ShortcutTrigger):
    """
    :Constructors:

    ::

        MnemonicTrigger(**properties)
        new(keyval:int) -> Gtk.MnemonicTrigger

    Object GtkMnemonicTrigger

    Properties from GtkMnemonicTrigger:
      keyval -> guint: keyval

    Signals from GObject:
      notify (GParam)
    """
    class Props(ShortcutTrigger.Props):
        keyval: int

    props: Props = ...
    def __init__(self, keyval: int = ...) -> None: ...
    def get_keyval(self) -> int: ...
    @classmethod
    def new(cls, keyval: int) -> MnemonicTrigger: ...

class MnemonicTriggerClass(GObject.GPointer): ...

class MountOperation(Gio.MountOperation):
    """
    :Constructors:

    ::

        MountOperation(**properties)
        new(parent:Gtk.Window=None) -> Gio.MountOperation

    Object GtkMountOperation

    Properties from GtkMountOperation:
      parent -> GtkWindow: parent
      is-showing -> gboolean: is-showing
      display -> GdkDisplay: display

    Signals from GMountOperation:
      ask-password (gchararray, gchararray, gchararray, GAskPasswordFlags)
      ask-question (gchararray, GStrv)
      reply (GMountOperationResult)
      aborted ()
      show-processes (gchararray, GArray, GStrv)
      show-unmount-progress (gchararray, gint64, gint64)

    Properties from GMountOperation:
      username -> gchararray: username
      password -> gchararray: password
      anonymous -> gboolean: anonymous
      domain -> gchararray: domain
      password-save -> GPasswordSave: password-save
      choice -> gint: choice
      is-tcrypt-hidden-volume -> gboolean: is-tcrypt-hidden-volume
      is-tcrypt-system-volume -> gboolean: is-tcrypt-system-volume
      pim -> guint: pim

    Signals from GObject:
      notify (GParam)
    """
    class Props(Gio.MountOperation.Props):
        display: Gdk.Display
        is_showing: bool
        parent: typing.Optional[Window]
        anonymous: bool
        choice: int
        domain: typing.Optional[str]
        is_tcrypt_hidden_volume: bool
        is_tcrypt_system_volume: bool
        password: typing.Optional[str]
        password_save: Gio.PasswordSave
        pim: int
        username: typing.Optional[str]

    props: Props = ...
    parent_instance: Gio.MountOperation = ...
    priv: MountOperationPrivate = ...
    def __init__(
        self,
        display: Gdk.Display = ...,
        parent: typing.Optional[Window] = ...,
        anonymous: bool = ...,
        choice: int = ...,
        domain: typing.Optional[str] = ...,
        is_tcrypt_hidden_volume: bool = ...,
        is_tcrypt_system_volume: bool = ...,
        password: typing.Optional[str] = ...,
        password_save: Gio.PasswordSave = ...,
        pim: int = ...,
        username: typing.Optional[str] = ...,
    ) -> None: ...
    def get_display(self) -> Gdk.Display: ...
    def get_parent(self) -> typing.Optional[Window]: ...
    def is_showing(self) -> bool: ...
    @classmethod
    def new(cls, parent: typing.Optional[Window] = None) -> MountOperation: ...
    def set_display(self, display: Gdk.Display) -> None: ...
    def set_parent(self, parent: typing.Optional[Window] = None) -> None: ...

class MountOperationClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MountOperationClass()
    """

    parent_class: Gio.MountOperationClass = ...

class MountOperationPrivate(GObject.GPointer): ...

# override
class MultiFilter(Filter, Gio.ListModel[typing.Any], Buildable):
    """
    :Constructors:

    ::

        MultiFilter(**properties)

    Object GtkMultiFilter

    Properties from GtkMultiFilter:
      item-type -> GType: item-type
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Filter.Props):
        item_type: typing.Type[typing.Any]
        n_items: int

    props: Props = ...
    def append(self, filter: Filter) -> None: ...
    def remove(self, position: int) -> None: ...

class MultiFilterClass(GObject.GPointer): ...

# override
class MultiSelection(
    GObject.Object, Gio.ListModel[typing.Any], SectionModel, SelectionModel
):
    """
    :Constructors:

    ::

        MultiSelection(**properties)
        new(model:Gio.ListModel=None) -> Gtk.MultiSelection

    Object GtkMultiSelection

    Properties from GtkMultiSelection:
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GtkSelectionModel:
      selection-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int

    props: Props = ...
    def __init__(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = ...
    ) -> None: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    @classmethod
    def new(
        cls, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> MultiSelection: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...

class MultiSelectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MultiSelectionClass()
    """

    parent_class: GObject.ObjectClass = ...

# override
class MultiSorter(Sorter, Gio.ListModel[typing.Any], Buildable):
    """
    :Constructors:

    ::

        MultiSorter(**properties)
        new() -> Gtk.MultiSorter

    Object GtkMultiSorter

    Properties from GtkMultiSorter:
      item-type -> GType: item-type
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Sorter.Props):
        item_type: typing.Type[typing.Any]
        n_items: int

    props: Props = ...
    def append(self, sorter: Sorter) -> None: ...
    @classmethod
    def new(cls) -> MultiSorter: ...
    def remove(self, position: int) -> None: ...

class MultiSorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MultiSorterClass()
    """

    parent_class: SorterClass = ...

class NamedAction(ShortcutAction):
    """
    :Constructors:

    ::

        NamedAction(**properties)
        new(name:str) -> Gtk.NamedAction

    Object GtkNamedAction

    Properties from GtkNamedAction:
      action-name -> gchararray: action-name

    Signals from GObject:
      notify (GParam)
    """
    class Props(ShortcutAction.Props):
        action_name: str

    props: Props = ...
    def __init__(self, action_name: str = ...) -> None: ...
    def get_action_name(self) -> str: ...
    @classmethod
    def new(cls, name: str) -> NamedAction: ...

class NamedActionClass(GObject.GPointer): ...

class Native(GObject.GInterface):
    """
    Interface GtkNative

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get_for_surface(surface: Gdk.Surface) -> typing.Optional[Native]: ...
    def get_renderer(self) -> typing.Optional[Gsk.Renderer]: ...
    def get_surface(self) -> typing.Optional[Gdk.Surface]: ...
    def get_surface_transform(self) -> typing.Tuple[float, float]: ...
    def realize(self) -> None: ...
    def unrealize(self) -> None: ...

class NativeDialog(GObject.Object):
    """
    :Constructors:

    ::

        NativeDialog(**properties)

    Object GtkNativeDialog

    Signals from GtkNativeDialog:
      response (gint)

    Properties from GtkNativeDialog:
      title -> gchararray: title
      visible -> gboolean: visible
      modal -> gboolean: modal
      transient-for -> GtkWindow: transient-for

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        modal: bool
        title: typing.Optional[str]
        transient_for: typing.Optional[Window]
        visible: bool

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(
        self,
        modal: bool = ...,
        title: str = ...,
        transient_for: typing.Optional[Window] = ...,
        visible: bool = ...,
    ) -> None: ...
    def destroy(self) -> None: ...
    def do_hide(self) -> None: ...
    def do_response(self, response_id: int) -> None: ...
    def do_show(self) -> None: ...
    def get_modal(self) -> bool: ...
    def get_title(self) -> typing.Optional[str]: ...
    def get_transient_for(self) -> typing.Optional[Window]: ...
    def get_visible(self) -> bool: ...
    def hide(self) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_title(self, title: str) -> None: ...
    def set_transient_for(self, parent: typing.Optional[Window] = None) -> None: ...
    def show(self) -> None: ...

class NativeDialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NativeDialogClass()
    """

    parent_class: GObject.ObjectClass = ...
    response: typing.Callable[[NativeDialog, int], None] = ...
    show: typing.Callable[[NativeDialog], None] = ...
    hide: typing.Callable[[NativeDialog], None] = ...

class NativeInterface(GObject.GPointer): ...

class NeverTrigger(ShortcutTrigger):
    """
    :Constructors:

    ::

        NeverTrigger(**properties)

    Object GtkNeverTrigger

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get() -> NeverTrigger: ...

class NeverTriggerClass(GObject.GPointer): ...

# override
class NoSelection(
    GObject.Object, Gio.ListModel[typing.Any], SectionModel, SelectionModel
):
    """
    :Constructors:

    ::

        NoSelection(**properties)
        new(model:Gio.ListModel=None) -> Gtk.NoSelection

    Object GtkNoSelection

    Properties from GtkNoSelection:
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GtkSelectionModel:
      selection-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int

    props: Props = ...
    def __init__(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = ...
    ) -> None: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    @classmethod
    def new(
        cls, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> NoSelection: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...

class NoSelectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NoSelectionClass()
    """

    parent_class: GObject.ObjectClass = ...

class Notebook(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Notebook(**properties)
        new() -> Gtk.Widget

    Object GtkNotebook

    Signals from GtkNotebook:
      switch-page (GtkWidget, guint)
      focus-tab (GtkNotebookTab) -> gboolean
      select-page (gboolean) -> gboolean
      change-current-page (gint) -> gboolean
      move-focus-out (GtkDirectionType)
      reorder-tab (GtkDirectionType, gboolean) -> gboolean
      page-reordered (GtkWidget, guint)
      page-removed (GtkWidget, guint)
      page-added (GtkWidget, guint)
      create-window (GtkWidget) -> GtkNotebook

    Properties from GtkNotebook:
      tab-pos -> GtkPositionType: tab-pos
      show-tabs -> gboolean: show-tabs
      show-border -> gboolean: show-border
      scrollable -> gboolean: scrollable
      page -> gint: page
      enable-popup -> gboolean: enable-popup
      group-name -> gchararray: group-name
      pages -> GListModel: pages

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(Widget.Props):
        enable_popup: bool
        group_name: typing.Optional[str]
        page: int
        pages: Gio.ListModel[typing.Any]
        scrollable: bool
        show_border: bool
        show_tabs: bool
        tab_pos: PositionType
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        enable_popup: bool = ...,
        group_name: typing.Optional[str] = ...,
        page: int = ...,
        scrollable: bool = ...,
        show_border: bool = ...,
        show_tabs: bool = ...,
        tab_pos: PositionType = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def append_page(
        self, child: Widget, tab_label: typing.Optional[Widget] = None
    ) -> int: ...
    def append_page_menu(
        self,
        child: Widget,
        tab_label: typing.Optional[Widget] = None,
        menu_label: typing.Optional[Widget] = None,
    ) -> int: ...
    def detach_tab(self, child: Widget) -> None: ...
    def get_action_widget(self, pack_type: PackType) -> typing.Optional[Widget]: ...
    def get_current_page(self) -> int: ...
    def get_group_name(self) -> typing.Optional[str]: ...
    def get_menu_label(self, child: Widget) -> typing.Optional[Widget]: ...
    def get_menu_label_text(self, child: Widget) -> typing.Optional[str]: ...
    def get_n_pages(self) -> int: ...
    def get_nth_page(self, page_num: int) -> typing.Optional[Widget]: ...
    def get_page(self, child: Widget) -> NotebookPage: ...
    # override
    def get_pages(self) -> Gio.ListModel[typing.Any]: ...
    def get_scrollable(self) -> bool: ...
    def get_show_border(self) -> bool: ...
    def get_show_tabs(self) -> bool: ...
    def get_tab_detachable(self, child: Widget) -> bool: ...
    def get_tab_label(self, child: Widget) -> typing.Optional[Widget]: ...
    def get_tab_label_text(self, child: Widget) -> typing.Optional[str]: ...
    def get_tab_pos(self) -> PositionType: ...
    def get_tab_reorderable(self, child: Widget) -> bool: ...
    def insert_page(
        self, child: Widget, tab_label: typing.Optional[Widget], position: int
    ) -> int: ...
    def insert_page_menu(
        self,
        child: Widget,
        tab_label: typing.Optional[Widget],
        menu_label: typing.Optional[Widget],
        position: int,
    ) -> int: ...
    @classmethod
    def new(cls) -> Notebook: ...
    def next_page(self) -> None: ...
    def page_num(self, child: Widget) -> int: ...
    def popup_disable(self) -> None: ...
    def popup_enable(self) -> None: ...
    def prepend_page(
        self, child: Widget, tab_label: typing.Optional[Widget] = None
    ) -> int: ...
    def prepend_page_menu(
        self,
        child: Widget,
        tab_label: typing.Optional[Widget] = None,
        menu_label: typing.Optional[Widget] = None,
    ) -> int: ...
    def prev_page(self) -> None: ...
    def remove_page(self, page_num: int) -> None: ...
    def reorder_child(self, child: Widget, position: int) -> None: ...
    def set_action_widget(self, widget: Widget, pack_type: PackType) -> None: ...
    def set_current_page(self, page_num: int) -> None: ...
    def set_group_name(self, group_name: typing.Optional[str] = None) -> None: ...
    def set_menu_label(
        self, child: Widget, menu_label: typing.Optional[Widget] = None
    ) -> None: ...
    def set_menu_label_text(self, child: Widget, menu_text: str) -> None: ...
    def set_scrollable(self, scrollable: bool) -> None: ...
    def set_show_border(self, show_border: bool) -> None: ...
    def set_show_tabs(self, show_tabs: bool) -> None: ...
    def set_tab_detachable(self, child: Widget, detachable: bool) -> None: ...
    def set_tab_label(
        self, child: Widget, tab_label: typing.Optional[Widget] = None
    ) -> None: ...
    def set_tab_label_text(self, child: Widget, tab_text: str) -> None: ...
    def set_tab_pos(self, pos: PositionType) -> None: ...
    def set_tab_reorderable(self, child: Widget, reorderable: bool) -> None: ...

class NotebookPage(GObject.Object):
    """
    :Constructors:

    ::

        NotebookPage(**properties)

    Object GtkNotebookPage

    Properties from GtkNotebookPage:
      tab-label -> gchararray: tab-label
      menu-label -> gchararray: menu-label
      position -> gint: position
      tab-expand -> gboolean: tab-expand
      tab-fill -> gboolean: tab-fill
      reorderable -> gboolean: reorderable
      detachable -> gboolean: detachable
      child -> GtkWidget: child
      tab -> GtkWidget: tab
      menu -> GtkWidget: menu

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        child: Widget
        detachable: bool
        menu: Widget
        menu_label: str
        position: int
        reorderable: bool
        tab: Widget
        tab_expand: bool
        tab_fill: bool
        tab_label: str

    props: Props = ...
    def __init__(
        self,
        child: Widget = ...,
        detachable: bool = ...,
        menu: Widget = ...,
        menu_label: str = ...,
        position: int = ...,
        reorderable: bool = ...,
        tab: Widget = ...,
        tab_expand: bool = ...,
        tab_fill: bool = ...,
        tab_label: str = ...,
    ) -> None: ...
    def get_child(self) -> Widget: ...

class NothingAction(ShortcutAction):
    """
    :Constructors:

    ::

        NothingAction(**properties)

    Object GtkNothingAction

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get() -> NothingAction: ...

class NothingActionClass(GObject.GPointer): ...

class NumericSorter(Sorter):
    """
    :Constructors:

    ::

        NumericSorter(**properties)
        new(expression:Gtk.Expression=None) -> Gtk.NumericSorter

    Object GtkNumericSorter

    Properties from GtkNumericSorter:
      expression -> GtkExpression: expression
      sort-order -> GtkSortType: sort-order

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Sorter.Props):
        expression: typing.Optional[Expression]
        sort_order: SortType

    props: Props = ...
    def __init__(
        self, expression: typing.Optional[Expression] = ..., sort_order: SortType = ...
    ) -> None: ...
    def get_expression(self) -> typing.Optional[Expression]: ...
    def get_sort_order(self) -> SortType: ...
    @classmethod
    def new(cls, expression: typing.Optional[Expression] = None) -> NumericSorter: ...
    def set_expression(
        self, expression: typing.Optional[Expression] = None
    ) -> None: ...
    def set_sort_order(self, sort_order: SortType) -> None: ...

class NumericSorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NumericSorterClass()
    """

    parent_class: SorterClass = ...

class ObjectExpression(Expression):
    """
    :Constructors:

    ::

        ObjectExpression(**properties)
        new(object:GObject.Object) -> Gtk.ObjectExpression
    """
    def get_object(self) -> typing.Optional[GObject.Object]: ...
    @classmethod
    def new(cls, object: GObject.Object) -> ObjectExpression: ...

class Orientable(GObject.GInterface):
    """
    Interface GtkOrientable

    Signals from GObject:
      notify (GParam)
    """
    def get_orientation(self) -> Orientation: ...
    def set_orientation(self, orientation: Orientation) -> None: ...

class OrientableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        OrientableIface()
    """

    base_iface: GObject.TypeInterface = ...

class Overlay(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Overlay(**properties)
        new() -> Gtk.Widget

    Object GtkOverlay

    Signals from GtkOverlay:
      get-child-position (GtkWidget, GdkRectangle) -> gboolean

    Properties from GtkOverlay:
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_overlay(self, widget: Widget) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_clip_overlay(self, widget: Widget) -> bool: ...
    def get_measure_overlay(self, widget: Widget) -> bool: ...
    @classmethod
    def new(cls) -> Overlay: ...
    def remove_overlay(self, widget: Widget) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_clip_overlay(self, widget: Widget, clip_overlay: bool) -> None: ...
    def set_measure_overlay(self, widget: Widget, measure: bool) -> None: ...

class OverlayLayout(LayoutManager):
    """
    :Constructors:

    ::

        OverlayLayout(**properties)
        new() -> Gtk.LayoutManager

    Object GtkOverlayLayout

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(cls) -> OverlayLayout: ...

class OverlayLayoutChild(LayoutChild):
    """
    :Constructors:

    ::

        OverlayLayoutChild(**properties)

    Object GtkOverlayLayoutChild

    Properties from GtkOverlayLayoutChild:
      measure -> gboolean: measure
      clip-overlay -> gboolean: clip-overlay

    Properties from GtkLayoutChild:
      layout-manager -> GtkLayoutManager: layout-manager
      child-widget -> GtkWidget: child-widget

    Signals from GObject:
      notify (GParam)
    """
    class Props(LayoutChild.Props):
        clip_overlay: bool
        measure: bool
        child_widget: Widget
        layout_manager: LayoutManager

    props: Props = ...
    def __init__(
        self,
        clip_overlay: bool = ...,
        measure: bool = ...,
        child_widget: Widget = ...,
        layout_manager: LayoutManager = ...,
    ) -> None: ...
    def get_clip_overlay(self) -> bool: ...
    def get_measure(self) -> bool: ...
    def set_clip_overlay(self, clip_overlay: bool) -> None: ...
    def set_measure(self, measure: bool) -> None: ...

class OverlayLayoutChildClass(GObject.GPointer):
    """
    :Constructors:

    ::

        OverlayLayoutChildClass()
    """

    parent_class: LayoutChildClass = ...

class OverlayLayoutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        OverlayLayoutClass()
    """

    parent_class: LayoutManagerClass = ...

class PadActionEntry(GObject.GPointer):
    """
    :Constructors:

    ::

        PadActionEntry()
    """

    type: PadActionType = ...
    index: int = ...
    mode: int = ...
    label: str = ...
    action_name: str = ...

class PadController(EventController):
    """
    :Constructors:

    ::

        PadController(**properties)
        new(group:Gio.ActionGroup, pad:Gdk.Device=None) -> Gtk.PadController

    Object GtkPadController

    Properties from GtkPadController:
      action-group -> GActionGroup: action-group
      pad -> GdkDevice: pad

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        action_group: Gio.ActionGroup
        pad: Gdk.Device
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(
        self,
        action_group: Gio.ActionGroup = ...,
        pad: Gdk.Device = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    @classmethod
    def new(
        cls, group: Gio.ActionGroup, pad: typing.Optional[Gdk.Device] = None
    ) -> PadController: ...
    def set_action(
        self, type: PadActionType, index: int, mode: int, label: str, action_name: str
    ) -> None: ...
    def set_action_entries(self, entries: typing.Sequence[PadActionEntry]) -> None: ...

class PadControllerClass(GObject.GPointer): ...

class PageRange(GObject.GPointer):
    """
    :Constructors:

    ::

        PageRange()
    """

    start: int = ...
    end: int = ...

class PageSetup(GObject.Object):
    """
    :Constructors:

    ::

        PageSetup(**properties)
        new() -> Gtk.PageSetup
        new_from_file(file_name:str) -> Gtk.PageSetup
        new_from_gvariant(variant:GLib.Variant) -> Gtk.PageSetup
        new_from_key_file(key_file:GLib.KeyFile, group_name:str=None) -> Gtk.PageSetup

    Object GtkPageSetup

    Signals from GObject:
      notify (GParam)
    """
    def copy(self) -> PageSetup: ...
    def get_bottom_margin(self, unit: Unit) -> float: ...
    def get_left_margin(self, unit: Unit) -> float: ...
    def get_orientation(self) -> PageOrientation: ...
    def get_page_height(self, unit: Unit) -> float: ...
    def get_page_width(self, unit: Unit) -> float: ...
    def get_paper_height(self, unit: Unit) -> float: ...
    def get_paper_size(self) -> PaperSize: ...
    def get_paper_width(self, unit: Unit) -> float: ...
    def get_right_margin(self, unit: Unit) -> float: ...
    def get_top_margin(self, unit: Unit) -> float: ...
    def load_file(self, file_name: str) -> bool: ...
    def load_key_file(
        self, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> bool: ...
    @classmethod
    def new(cls) -> PageSetup: ...
    @classmethod
    def new_from_file(cls, file_name: str) -> PageSetup: ...
    @classmethod
    def new_from_gvariant(cls, variant: GLib.Variant) -> PageSetup: ...
    @classmethod
    def new_from_key_file(
        cls, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> PageSetup: ...
    def set_bottom_margin(self, margin: float, unit: Unit) -> None: ...
    def set_left_margin(self, margin: float, unit: Unit) -> None: ...
    def set_orientation(self, orientation: PageOrientation) -> None: ...
    def set_paper_size(self, size: PaperSize) -> None: ...
    def set_paper_size_and_default_margins(self, size: PaperSize) -> None: ...
    def set_right_margin(self, margin: float, unit: Unit) -> None: ...
    def set_top_margin(self, margin: float, unit: Unit) -> None: ...
    def to_file(self, file_name: str) -> bool: ...
    def to_gvariant(self) -> GLib.Variant: ...
    def to_key_file(
        self, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> None: ...

class PageSetupUnixDialog(
    Dialog, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        PageSetupUnixDialog(**properties)
        new(title:str=None, parent:Gtk.Window=None) -> Gtk.Widget

    Object GtkPageSetupUnixDialog

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Dialog.Props):
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_page_setup(self) -> PageSetup: ...
    def get_print_settings(self) -> typing.Optional[PrintSettings]: ...
    @classmethod
    def new(
        cls, title: typing.Optional[str] = None, parent: typing.Optional[Window] = None
    ) -> PageSetupUnixDialog: ...
    def set_page_setup(self, page_setup: PageSetup) -> None: ...
    def set_print_settings(
        self, print_settings: typing.Optional[PrintSettings] = None
    ) -> None: ...

class Paned(
    Widget, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        Paned(**properties)
        new(orientation:Gtk.Orientation) -> Gtk.Widget

    Object GtkPaned

    Signals from GtkPaned:
      cycle-child-focus (gboolean) -> gboolean
      toggle-handle-focus () -> gboolean
      move-handle (GtkScrollType) -> gboolean
      cycle-handle-focus (gboolean) -> gboolean
      accept-position () -> gboolean
      cancel-position () -> gboolean

    Properties from GtkPaned:
      position -> gint: position
      position-set -> gboolean: position-set
      min-position -> gint: min-position
      max-position -> gint: max-position
      wide-handle -> gboolean: wide-handle
      resize-start-child -> gboolean: resize-start-child
      resize-end-child -> gboolean: resize-end-child
      shrink-start-child -> gboolean: shrink-start-child
      shrink-end-child -> gboolean: shrink-end-child
      start-child -> GtkWidget: start-child
      end-child -> GtkWidget: end-child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        end_child: typing.Optional[Widget]
        max_position: int
        min_position: int
        position: int
        position_set: bool
        resize_end_child: bool
        resize_start_child: bool
        shrink_end_child: bool
        shrink_start_child: bool
        start_child: typing.Optional[Widget]
        wide_handle: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        end_child: typing.Optional[Widget] = ...,
        position: int = ...,
        position_set: bool = ...,
        resize_end_child: bool = ...,
        resize_start_child: bool = ...,
        shrink_end_child: bool = ...,
        shrink_start_child: bool = ...,
        start_child: typing.Optional[Widget] = ...,
        wide_handle: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_end_child(self) -> typing.Optional[Widget]: ...
    def get_position(self) -> int: ...
    def get_resize_end_child(self) -> bool: ...
    def get_resize_start_child(self) -> bool: ...
    def get_shrink_end_child(self) -> bool: ...
    def get_shrink_start_child(self) -> bool: ...
    def get_start_child(self) -> typing.Optional[Widget]: ...
    def get_wide_handle(self) -> bool: ...
    @classmethod
    def new(cls, orientation: Orientation) -> Paned: ...
    def set_end_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_position(self, position: int) -> None: ...
    def set_resize_end_child(self, resize: bool) -> None: ...
    def set_resize_start_child(self, resize: bool) -> None: ...
    def set_shrink_end_child(self, resize: bool) -> None: ...
    def set_shrink_start_child(self, resize: bool) -> None: ...
    def set_start_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_wide_handle(self, wide: bool) -> None: ...

class PaperSize(GObject.GBoxed):
    """
    :Constructors:

    ::

        new(name:str=None) -> Gtk.PaperSize
        new_custom(name:str, display_name:str, width:float, height:float, unit:Gtk.Unit) -> Gtk.PaperSize
        new_from_gvariant(variant:GLib.Variant) -> Gtk.PaperSize
        new_from_ipp(ipp_name:str, width:float, height:float) -> Gtk.PaperSize
        new_from_key_file(key_file:GLib.KeyFile, group_name:str=None) -> Gtk.PaperSize
        new_from_ppd(ppd_name:str, ppd_display_name:str, width:float, height:float) -> Gtk.PaperSize
    """
    def copy(self) -> PaperSize: ...
    def free(self) -> None: ...
    @staticmethod
    def get_default() -> str: ...
    def get_default_bottom_margin(self, unit: Unit) -> float: ...
    def get_default_left_margin(self, unit: Unit) -> float: ...
    def get_default_right_margin(self, unit: Unit) -> float: ...
    def get_default_top_margin(self, unit: Unit) -> float: ...
    def get_display_name(self) -> str: ...
    def get_height(self, unit: Unit) -> float: ...
    def get_name(self) -> str: ...
    @staticmethod
    def get_paper_sizes(include_custom: bool) -> list[PaperSize]: ...
    def get_ppd_name(self) -> str: ...
    def get_width(self, unit: Unit) -> float: ...
    def is_custom(self) -> bool: ...
    def is_equal(self, size2: PaperSize) -> bool: ...
    def is_ipp(self) -> bool: ...
    @classmethod
    def new(cls, name: typing.Optional[str] = None) -> PaperSize: ...
    @classmethod
    def new_custom(
        cls, name: str, display_name: str, width: float, height: float, unit: Unit
    ) -> PaperSize: ...
    @classmethod
    def new_from_gvariant(cls, variant: GLib.Variant) -> PaperSize: ...
    @classmethod
    def new_from_ipp(cls, ipp_name: str, width: float, height: float) -> PaperSize: ...
    @classmethod
    def new_from_key_file(
        cls, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> PaperSize: ...
    @classmethod
    def new_from_ppd(
        cls, ppd_name: str, ppd_display_name: str, width: float, height: float
    ) -> PaperSize: ...
    def set_size(self, width: float, height: float, unit: Unit) -> None: ...
    def to_gvariant(self) -> GLib.Variant: ...
    def to_key_file(self, key_file: GLib.KeyFile, group_name: str) -> None: ...

class ParamSpecExpression(GObject.ParamSpec):
    """
    :Constructors:

    ::

        ParamSpecExpression(**properties)
    """

    parent_instance: GObject.ParamSpec = ...

class PasswordEntry(Widget, Accessible, Buildable, ConstraintTarget, Editable):
    """
    :Constructors:

    ::

        PasswordEntry(**properties)
        new() -> Gtk.Widget

    Object GtkPasswordEntry

    Signals from GtkPasswordEntry:
      activate ()

    Properties from GtkPasswordEntry:
      placeholder-text -> gchararray: placeholder-text
      activates-default -> gboolean: activates-default
      show-peek-icon -> gboolean: show-peek-icon
      extra-menu -> GMenuModel: extra-menu

    Signals from GtkEditable:
      changed ()
      insert-text (gchararray, gint, gpointer)
      delete-text (gint, gint)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activates_default: bool
        extra_menu: typing.Optional[Gio.MenuModel]
        placeholder_text: str
        show_peek_icon: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        cursor_position: int
        editable: bool
        enable_undo: bool
        max_width_chars: int
        selection_bound: int
        text: str
        width_chars: int
        xalign: float

    props: Props = ...
    def __init__(
        self,
        activates_default: bool = ...,
        extra_menu: typing.Optional[Gio.MenuModel] = ...,
        placeholder_text: str = ...,
        show_peek_icon: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editable: bool = ...,
        enable_undo: bool = ...,
        max_width_chars: int = ...,
        text: str = ...,
        width_chars: int = ...,
        xalign: float = ...,
    ) -> None: ...
    def get_extra_menu(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_show_peek_icon(self) -> bool: ...
    @classmethod
    def new(cls) -> PasswordEntry: ...
    def set_extra_menu(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def set_show_peek_icon(self, show_peek_icon: bool) -> None: ...

class PasswordEntryBuffer(EntryBuffer):
    """
    :Constructors:

    ::

        PasswordEntryBuffer(**properties)
        new() -> Gtk.EntryBuffer

    Object GtkPasswordEntryBuffer

    Signals from GtkEntryBuffer:
      inserted-text (guint, gchararray, guint)
      deleted-text (guint, guint)

    Properties from GtkEntryBuffer:
      text -> gchararray: text
      length -> guint: length
      max-length -> gint: max-length

    Signals from GObject:
      notify (GParam)
    """
    class Props(EntryBuffer.Props):
        length: int
        max_length: int
        text: str

    props: Props = ...
    def __init__(self, max_length: int = ..., text: str = ...) -> None: ...
    @classmethod
    def new(cls) -> PasswordEntryBuffer: ...

class PasswordEntryBufferClass(GObject.GPointer):
    """
    :Constructors:

    ::

        PasswordEntryBufferClass()
    """

    parent_class: EntryBufferClass = ...

class PasswordEntryClass(GObject.GPointer): ...

class Picture(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Picture(**properties)
        new() -> Gtk.Widget
        new_for_file(file:Gio.File=None) -> Gtk.Widget
        new_for_filename(filename:str=None) -> Gtk.Widget
        new_for_paintable(paintable:Gdk.Paintable=None) -> Gtk.Widget
        new_for_pixbuf(pixbuf:GdkPixbuf.Pixbuf=None) -> Gtk.Widget
        new_for_resource(resource_path:str=None) -> Gtk.Widget

    Object GtkPicture

    Properties from GtkPicture:
      paintable -> GdkPaintable: paintable
      file -> GFile: file
      alternative-text -> gchararray: alternative-text
      keep-aspect-ratio -> gboolean: keep-aspect-ratio
      can-shrink -> gboolean: can-shrink
      content-fit -> GtkContentFit: content-fit

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        alternative_text: typing.Optional[str]
        can_shrink: bool
        content_fit: ContentFit
        file: typing.Optional[Gio.File]
        keep_aspect_ratio: bool
        paintable: typing.Optional[Gdk.Paintable]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        alternative_text: typing.Optional[str] = ...,
        can_shrink: bool = ...,
        content_fit: ContentFit = ...,
        file: typing.Optional[Gio.File] = ...,
        keep_aspect_ratio: bool = ...,
        paintable: typing.Optional[Gdk.Paintable] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_alternative_text(self) -> typing.Optional[str]: ...
    def get_can_shrink(self) -> bool: ...
    def get_content_fit(self) -> ContentFit: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_keep_aspect_ratio(self) -> bool: ...
    def get_paintable(self) -> typing.Optional[Gdk.Paintable]: ...
    @classmethod
    def new(cls) -> Picture: ...
    @classmethod
    def new_for_file(cls, file: typing.Optional[Gio.File] = None) -> Picture: ...
    @classmethod
    def new_for_filename(cls, filename: typing.Optional[str] = None) -> Picture: ...
    @classmethod
    def new_for_paintable(
        cls, paintable: typing.Optional[Gdk.Paintable] = None
    ) -> Picture: ...
    @classmethod
    def new_for_pixbuf(
        cls, pixbuf: typing.Optional[GdkPixbuf.Pixbuf] = None
    ) -> Picture: ...
    @classmethod
    def new_for_resource(
        cls, resource_path: typing.Optional[str] = None
    ) -> Picture: ...
    def set_alternative_text(
        self, alternative_text: typing.Optional[str] = None
    ) -> None: ...
    def set_can_shrink(self, can_shrink: bool) -> None: ...
    def set_content_fit(self, content_fit: ContentFit) -> None: ...
    def set_file(self, file: typing.Optional[Gio.File] = None) -> None: ...
    def set_filename(self, filename: typing.Optional[str] = None) -> None: ...
    def set_keep_aspect_ratio(self, keep_aspect_ratio: bool) -> None: ...
    def set_paintable(
        self, paintable: typing.Optional[Gdk.Paintable] = None
    ) -> None: ...
    def set_pixbuf(self, pixbuf: typing.Optional[GdkPixbuf.Pixbuf] = None) -> None: ...
    def set_resource(self, resource_path: typing.Optional[str] = None) -> None: ...

class PictureClass(GObject.GPointer):
    """
    :Constructors:

    ::

        PictureClass()
    """

    parent_class: WidgetClass = ...

class Popover(Widget, Accessible, Buildable, ConstraintTarget, Native, ShortcutManager):
    """
    :Constructors:

    ::

        Popover(**properties)
        new() -> Gtk.Widget

    Object GtkPopover

    Signals from GtkPopover:
      closed ()
      activate-default ()

    Properties from GtkPopover:
      pointing-to -> GdkRectangle: pointing-to
      position -> GtkPositionType: position
      autohide -> gboolean: autohide
      default-widget -> GtkWidget: default-widget
      has-arrow -> gboolean: has-arrow
      mnemonics-visible -> gboolean: mnemonics-visible
      child -> GtkWidget: child
      cascade-popdown -> gboolean: cascade-popdown

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        autohide: bool
        cascade_popdown: bool
        child: typing.Optional[Widget]
        default_widget: typing.Optional[Widget]
        has_arrow: bool
        mnemonics_visible: bool
        pointing_to: Gdk.Rectangle
        position: PositionType
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    parent: Widget = ...
    def __init__(
        self,
        autohide: bool = ...,
        cascade_popdown: bool = ...,
        child: typing.Optional[Widget] = ...,
        default_widget: typing.Optional[Widget] = ...,
        has_arrow: bool = ...,
        mnemonics_visible: bool = ...,
        pointing_to: typing.Optional[Gdk.Rectangle] = ...,
        position: PositionType = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def do_activate_default(self) -> None: ...
    def do_closed(self) -> None: ...
    def get_autohide(self) -> bool: ...
    def get_cascade_popdown(self) -> bool: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_has_arrow(self) -> bool: ...
    def get_mnemonics_visible(self) -> bool: ...
    def get_offset(self) -> typing.Tuple[int, int]: ...
    def get_pointing_to(self) -> typing.Tuple[bool, Gdk.Rectangle]: ...
    def get_position(self) -> PositionType: ...
    @classmethod
    def new(cls) -> Popover: ...
    def popdown(self) -> None: ...
    def popup(self) -> None: ...
    def present(self) -> None: ...
    def set_autohide(self, autohide: bool) -> None: ...
    def set_cascade_popdown(self, cascade_popdown: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_default_widget(self, widget: typing.Optional[Widget] = None) -> None: ...
    def set_has_arrow(self, has_arrow: bool) -> None: ...
    def set_mnemonics_visible(self, mnemonics_visible: bool) -> None: ...
    def set_offset(self, x_offset: int, y_offset: int) -> None: ...
    def set_pointing_to(self, rect: typing.Optional[Gdk.Rectangle] = None) -> None: ...
    def set_position(self, position: PositionType) -> None: ...

class PopoverClass(GObject.GPointer):
    """
    :Constructors:

    ::

        PopoverClass()
    """

    parent_class: WidgetClass = ...
    closed: typing.Callable[[Popover], None] = ...
    activate_default: typing.Callable[[Popover], None] = ...
    reserved: list[None] = ...

class PopoverMenu(
    Popover, Accessible, Buildable, ConstraintTarget, Native, ShortcutManager
):
    """
    :Constructors:

    ::

        PopoverMenu(**properties)
        new_from_model(model:Gio.MenuModel=None) -> Gtk.Widget
        new_from_model_full(model:Gio.MenuModel, flags:Gtk.PopoverMenuFlags) -> Gtk.Widget

    Object GtkPopoverMenu

    Properties from GtkPopoverMenu:
      visible-submenu -> gchararray: visible-submenu
      menu-model -> GMenuModel: menu-model
      flags -> GtkPopoverMenuFlags: flags

    Signals from GtkPopover:
      closed ()
      activate-default ()

    Properties from GtkPopover:
      pointing-to -> GdkRectangle: pointing-to
      position -> GtkPositionType: position
      autohide -> gboolean: autohide
      default-widget -> GtkWidget: default-widget
      has-arrow -> gboolean: has-arrow
      mnemonics-visible -> gboolean: mnemonics-visible
      child -> GtkWidget: child
      cascade-popdown -> gboolean: cascade-popdown

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Popover.Props):
        flags: PopoverMenuFlags
        menu_model: typing.Optional[Gio.MenuModel]
        visible_submenu: str
        autohide: bool
        cascade_popdown: bool
        child: typing.Optional[Widget]
        default_widget: typing.Optional[Widget]
        has_arrow: bool
        mnemonics_visible: bool
        pointing_to: Gdk.Rectangle
        position: PositionType
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        flags: PopoverMenuFlags = ...,
        menu_model: typing.Optional[Gio.MenuModel] = ...,
        visible_submenu: str = ...,
        autohide: bool = ...,
        cascade_popdown: bool = ...,
        child: typing.Optional[Widget] = ...,
        default_widget: typing.Optional[Widget] = ...,
        has_arrow: bool = ...,
        mnemonics_visible: bool = ...,
        pointing_to: typing.Optional[Gdk.Rectangle] = ...,
        position: PositionType = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_child(self, child: Widget, id: str) -> bool: ...
    def get_flags(self) -> PopoverMenuFlags: ...
    def get_menu_model(self) -> typing.Optional[Gio.MenuModel]: ...
    @classmethod
    def new_from_model(
        cls, model: typing.Optional[Gio.MenuModel] = None
    ) -> PopoverMenu: ...
    @classmethod
    def new_from_model_full(
        cls, model: Gio.MenuModel, flags: PopoverMenuFlags
    ) -> PopoverMenu: ...
    def remove_child(self, child: Widget) -> bool: ...
    def set_flags(self, flags: PopoverMenuFlags) -> None: ...
    def set_menu_model(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...

class PopoverMenuBar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        PopoverMenuBar(**properties)
        new_from_model(model:Gio.MenuModel=None) -> Gtk.Widget

    Object GtkPopoverMenuBar

    Properties from GtkPopoverMenuBar:
      menu-model -> GMenuModel: menu-model

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        menu_model: typing.Optional[Gio.MenuModel]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        menu_model: typing.Optional[Gio.MenuModel] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_child(self, child: Widget, id: str) -> bool: ...
    def get_menu_model(self) -> typing.Optional[Gio.MenuModel]: ...
    @classmethod
    def new_from_model(
        cls, model: typing.Optional[Gio.MenuModel] = None
    ) -> PopoverMenuBar: ...
    def remove_child(self, child: Widget) -> bool: ...
    def set_menu_model(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...

class PrintBackend(GObject.GPointer): ...

class PrintContext(GObject.Object):
    """
    :Constructors:

    ::

        PrintContext(**properties)

    Object GtkPrintContext

    Signals from GObject:
      notify (GParam)
    """
    def create_pango_context(self) -> Pango.Context: ...
    def create_pango_layout(self) -> Pango.Layout: ...
    def get_cairo_context(self) -> cairo.Context: ...
    def get_dpi_x(self) -> float: ...
    def get_dpi_y(self) -> float: ...
    def get_hard_margins(self) -> typing.Tuple[bool, float, float, float, float]: ...
    def get_height(self) -> float: ...
    def get_page_setup(self) -> PageSetup: ...
    def get_pango_fontmap(self) -> Pango.FontMap: ...
    def get_width(self) -> float: ...
    def set_cairo_context(
        self, cr: cairo.Context[_SomeSurface], dpi_x: float, dpi_y: float
    ) -> None: ...

class PrintDialog(GObject.Object):
    """
    :Constructors:

    ::

        PrintDialog(**properties)
        new() -> Gtk.PrintDialog

    Object GtkPrintDialog

    Properties from GtkPrintDialog:
      accept-label -> gchararray: accept-label
      page-setup -> GtkPageSetup: page-setup
      modal -> gboolean: modal
      print-settings -> GtkPrintSettings: print-settings
      title -> gchararray: title

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        accept_label: str
        modal: bool
        page_setup: typing.Optional[PageSetup]
        print_settings: typing.Optional[PrintSettings]
        title: str

    props: Props = ...
    def __init__(
        self,
        accept_label: str = ...,
        modal: bool = ...,
        page_setup: PageSetup = ...,
        print_settings: PrintSettings = ...,
        title: str = ...,
    ) -> None: ...
    def get_accept_label(self) -> str: ...
    def get_modal(self) -> bool: ...
    def get_page_setup(self) -> typing.Optional[PageSetup]: ...
    def get_print_settings(self) -> typing.Optional[PrintSettings]: ...
    def get_title(self) -> str: ...
    @classmethod
    def new(cls) -> PrintDialog: ...
    def print_(
        self,
        parent: typing.Optional[Window] = None,
        setup: typing.Optional[PrintSetup] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def print_file(
        self,
        parent: typing.Optional[Window],
        setup: typing.Optional[PrintSetup],
        file: Gio.File,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def print_file_finish(self, result: Gio.AsyncResult) -> bool: ...
    def print_finish(self, result: Gio.AsyncResult) -> Gio.OutputStream: ...
    def set_accept_label(self, accept_label: str) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_page_setup(self, page_setup: PageSetup) -> None: ...
    def set_print_settings(self, print_settings: PrintSettings) -> None: ...
    def set_title(self, title: str) -> None: ...
    def setup(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def setup_finish(self, result: Gio.AsyncResult) -> PrintSetup: ...

class PrintDialogClass(GObject.GPointer):
    """
    :Constructors:

    ::

        PrintDialogClass()
    """

    parent_class: GObject.ObjectClass = ...

class PrintJob(GObject.Object):
    """
    :Constructors:

    ::

        PrintJob(**properties)
        new(title:str, printer:Gtk.Printer, settings:Gtk.PrintSettings, page_setup:Gtk.PageSetup) -> Gtk.PrintJob

    Object GtkPrintJob

    Signals from GtkPrintJob:
      status-changed ()

    Properties from GtkPrintJob:
      title -> gchararray: title
      printer -> GtkPrinter: printer
      page-setup -> GtkPageSetup: page-setup
      settings -> GtkPrintSettings: settings
      track-print-status -> gboolean: track-print-status

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        page_setup: PageSetup
        printer: Printer
        settings: PrintSettings
        title: str
        track_print_status: bool

    props: Props = ...
    def __init__(
        self,
        page_setup: PageSetup = ...,
        printer: Printer = ...,
        settings: PrintSettings = ...,
        title: str = ...,
        track_print_status: bool = ...,
    ) -> None: ...
    def get_collate(self) -> bool: ...
    def get_n_up(self) -> int: ...
    def get_n_up_layout(self) -> NumberUpLayout: ...
    def get_num_copies(self) -> int: ...
    def get_page_ranges(self) -> list[PageRange]: ...
    def get_page_set(self) -> PageSet: ...
    def get_pages(self) -> PrintPages: ...
    def get_printer(self) -> Printer: ...
    def get_reverse(self) -> bool: ...
    def get_rotate(self) -> bool: ...
    def get_scale(self) -> float: ...
    def get_settings(self) -> PrintSettings: ...
    def get_status(self) -> PrintStatus: ...
    def get_surface(self) -> cairo.Surface: ...
    def get_title(self) -> str: ...
    def get_track_print_status(self) -> bool: ...
    @classmethod
    def new(
        cls,
        title: str,
        printer: Printer,
        settings: PrintSettings,
        page_setup: PageSetup,
    ) -> PrintJob: ...
    def send(
        self, callback: typing.Callable[..., None], *user_data: typing.Any
    ) -> None: ...
    def set_collate(self, collate: bool) -> None: ...
    def set_n_up(self, n_up: int) -> None: ...
    def set_n_up_layout(self, layout: NumberUpLayout) -> None: ...
    def set_num_copies(self, num_copies: int) -> None: ...
    def set_page_ranges(self, ranges: typing.Sequence[PageRange]) -> None: ...
    def set_page_set(self, page_set: PageSet) -> None: ...
    def set_pages(self, pages: PrintPages) -> None: ...
    def set_reverse(self, reverse: bool) -> None: ...
    def set_rotate(self, rotate: bool) -> None: ...
    def set_scale(self, scale: float) -> None: ...
    def set_source_fd(self, fd: int) -> bool: ...
    def set_source_file(self, filename: str) -> bool: ...
    def set_track_print_status(self, track_status: bool) -> None: ...

class PrintOperation(GObject.Object, PrintOperationPreview):
    """
    :Constructors:

    ::

        PrintOperation(**properties)
        new() -> Gtk.PrintOperation

    Object GtkPrintOperation

    Signals from GtkPrintOperation:
      status-changed ()
      done (GtkPrintOperationResult)
      begin-print (GtkPrintContext)
      paginate (GtkPrintContext) -> gboolean
      request-page-setup (GtkPrintContext, gint, GtkPageSetup)
      draw-page (GtkPrintContext, gint)
      end-print (GtkPrintContext)
      create-custom-widget () -> GObject
      update-custom-widget (GtkWidget, GtkPageSetup, GtkPrintSettings)
      custom-widget-apply (GtkWidget)
      preview (GtkPrintOperationPreview, GtkPrintContext, GtkWindow) -> gboolean

    Properties from GtkPrintOperation:
      default-page-setup -> GtkPageSetup: default-page-setup
      print-settings -> GtkPrintSettings: print-settings
      job-name -> gchararray: job-name
      n-pages -> gint: n-pages
      current-page -> gint: current-page
      use-full-page -> gboolean: use-full-page
      track-print-status -> gboolean: track-print-status
      unit -> GtkUnit: unit
      show-progress -> gboolean: show-progress
      allow-async -> gboolean: allow-async
      export-filename -> gchararray: export-filename
      status -> GtkPrintStatus: status
      status-string -> gchararray: status-string
      custom-tab-label -> gchararray: custom-tab-label
      embed-page-setup -> gboolean: embed-page-setup
      has-selection -> gboolean: has-selection
      support-selection -> gboolean: support-selection
      n-pages-to-print -> gint: n-pages-to-print

    Signals from GtkPrintOperationPreview:
      ready (GtkPrintContext)
      got-page-size (GtkPrintContext, GtkPageSetup)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        allow_async: bool
        current_page: int
        custom_tab_label: typing.Optional[str]
        default_page_setup: PageSetup
        embed_page_setup: bool
        export_filename: str
        has_selection: bool
        job_name: str
        n_pages: int
        n_pages_to_print: int
        print_settings: typing.Optional[PrintSettings]
        show_progress: bool
        status: PrintStatus
        status_string: str
        support_selection: bool
        track_print_status: bool
        unit: Unit
        use_full_page: bool

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: PrintOperationPrivate = ...
    def __init__(
        self,
        allow_async: bool = ...,
        current_page: int = ...,
        custom_tab_label: typing.Optional[str] = ...,
        default_page_setup: typing.Optional[PageSetup] = ...,
        embed_page_setup: bool = ...,
        export_filename: str = ...,
        has_selection: bool = ...,
        job_name: str = ...,
        n_pages: int = ...,
        print_settings: typing.Optional[PrintSettings] = ...,
        show_progress: bool = ...,
        support_selection: bool = ...,
        track_print_status: bool = ...,
        unit: Unit = ...,
        use_full_page: bool = ...,
    ) -> None: ...
    def cancel(self) -> None: ...
    def do_begin_print(self, context: PrintContext) -> None: ...
    def do_custom_widget_apply(self, widget: Widget) -> None: ...
    def do_done(self, result: PrintOperationResult) -> None: ...
    def do_draw_page(self, context: PrintContext, page_nr: int) -> None: ...
    def do_end_print(self, context: PrintContext) -> None: ...
    def do_paginate(self, context: PrintContext) -> bool: ...
    def do_preview(
        self, preview: PrintOperationPreview, context: PrintContext, parent: Window
    ) -> bool: ...
    def do_request_page_setup(
        self, context: PrintContext, page_nr: int, setup: PageSetup
    ) -> None: ...
    def do_status_changed(self) -> None: ...
    def do_update_custom_widget(
        self, widget: Widget, setup: PageSetup, settings: PrintSettings
    ) -> None: ...
    def draw_page_finish(self) -> None: ...
    def get_default_page_setup(self) -> PageSetup: ...
    def get_embed_page_setup(self) -> bool: ...
    def get_error(self) -> None: ...
    def get_has_selection(self) -> bool: ...
    def get_n_pages_to_print(self) -> int: ...
    def get_print_settings(self) -> typing.Optional[PrintSettings]: ...
    def get_status(self) -> PrintStatus: ...
    def get_status_string(self) -> str: ...
    def get_support_selection(self) -> bool: ...
    def is_finished(self) -> bool: ...
    @classmethod
    def new(cls) -> PrintOperation: ...
    def run(
        self, action: PrintOperationAction, parent: typing.Optional[Window] = None
    ) -> PrintOperationResult: ...
    def set_allow_async(self, allow_async: bool) -> None: ...
    def set_current_page(self, current_page: int) -> None: ...
    def set_custom_tab_label(self, label: typing.Optional[str] = None) -> None: ...
    def set_default_page_setup(
        self, default_page_setup: typing.Optional[PageSetup] = None
    ) -> None: ...
    def set_defer_drawing(self) -> None: ...
    def set_embed_page_setup(self, embed: bool) -> None: ...
    def set_export_filename(self, filename: str) -> None: ...
    def set_has_selection(self, has_selection: bool) -> None: ...
    def set_job_name(self, job_name: str) -> None: ...
    def set_n_pages(self, n_pages: int) -> None: ...
    def set_print_settings(
        self, print_settings: typing.Optional[PrintSettings] = None
    ) -> None: ...
    def set_show_progress(self, show_progress: bool) -> None: ...
    def set_support_selection(self, support_selection: bool) -> None: ...
    def set_track_print_status(self, track_status: bool) -> None: ...
    def set_unit(self, unit: Unit) -> None: ...
    def set_use_full_page(self, full_page: bool) -> None: ...

class PrintOperationClass(GObject.GPointer):
    """
    :Constructors:

    ::

        PrintOperationClass()
    """

    parent_class: GObject.ObjectClass = ...
    done: typing.Callable[[PrintOperation, PrintOperationResult], None] = ...
    begin_print: typing.Callable[[PrintOperation, PrintContext], None] = ...
    paginate: typing.Callable[[PrintOperation, PrintContext], bool] = ...
    request_page_setup: typing.Callable[
        [PrintOperation, PrintContext, int, PageSetup], None
    ] = ...
    draw_page: typing.Callable[[PrintOperation, PrintContext, int], None] = ...
    end_print: typing.Callable[[PrintOperation, PrintContext], None] = ...
    status_changed: typing.Callable[[PrintOperation], None] = ...
    create_custom_widget: None = ...
    custom_widget_apply: typing.Callable[[PrintOperation, Widget], None] = ...
    preview: typing.Callable[
        [PrintOperation, PrintOperationPreview, PrintContext, Window], bool
    ] = ...
    update_custom_widget: typing.Callable[
        [PrintOperation, Widget, PageSetup, PrintSettings], None
    ] = ...
    padding: list[None] = ...

class PrintOperationPreview(GObject.GInterface):
    """
    Interface GtkPrintOperationPreview

    Signals from GObject:
      notify (GParam)
    """
    def end_preview(self) -> None: ...
    def is_selected(self, page_nr: int) -> bool: ...
    def render_page(self, page_nr: int) -> None: ...

class PrintOperationPreviewIface(GObject.GPointer):
    """
    :Constructors:

    ::

        PrintOperationPreviewIface()
    """

    g_iface: GObject.TypeInterface = ...
    ready: typing.Callable[[PrintOperationPreview, PrintContext], None] = ...
    got_page_size: typing.Callable[
        [PrintOperationPreview, PrintContext, PageSetup], None
    ] = ...
    render_page: typing.Callable[[PrintOperationPreview, int], None] = ...
    is_selected: typing.Callable[[PrintOperationPreview, int], bool] = ...
    end_preview: typing.Callable[[PrintOperationPreview], None] = ...

class PrintOperationPrivate(GObject.GPointer): ...

class PrintSettings(GObject.Object):
    """
    :Constructors:

    ::

        PrintSettings(**properties)
        new() -> Gtk.PrintSettings
        new_from_file(file_name:str) -> Gtk.PrintSettings
        new_from_gvariant(variant:GLib.Variant) -> Gtk.PrintSettings
        new_from_key_file(key_file:GLib.KeyFile, group_name:str=None) -> Gtk.PrintSettings

    Object GtkPrintSettings

    Signals from GObject:
      notify (GParam)
    """
    def copy(self) -> PrintSettings: ...
    def foreach(
        self, func: typing.Callable[..., None], *user_data: typing.Any
    ) -> None: ...
    def get(self, key: str) -> typing.Optional[str]: ...
    def get_bool(self, key: str) -> bool: ...
    def get_collate(self) -> bool: ...
    def get_default_source(self) -> typing.Optional[str]: ...
    def get_dither(self) -> typing.Optional[str]: ...
    def get_double(self, key: str) -> float: ...
    def get_double_with_default(self, key: str, def_: float) -> float: ...
    def get_duplex(self) -> PrintDuplex: ...
    def get_finishings(self) -> typing.Optional[str]: ...
    def get_int(self, key: str) -> int: ...
    def get_int_with_default(self, key: str, def_: int) -> int: ...
    def get_length(self, key: str, unit: Unit) -> float: ...
    def get_media_type(self) -> typing.Optional[str]: ...
    def get_n_copies(self) -> int: ...
    def get_number_up(self) -> int: ...
    def get_number_up_layout(self) -> NumberUpLayout: ...
    def get_orientation(self) -> PageOrientation: ...
    def get_output_bin(self) -> typing.Optional[str]: ...
    def get_page_ranges(self) -> list[PageRange]: ...
    def get_page_set(self) -> PageSet: ...
    def get_paper_height(self, unit: Unit) -> float: ...
    def get_paper_size(self) -> typing.Optional[PaperSize]: ...
    def get_paper_width(self, unit: Unit) -> float: ...
    def get_print_pages(self) -> PrintPages: ...
    def get_printer(self) -> typing.Optional[str]: ...
    def get_printer_lpi(self) -> float: ...
    def get_quality(self) -> PrintQuality: ...
    def get_resolution(self) -> int: ...
    def get_resolution_x(self) -> int: ...
    def get_resolution_y(self) -> int: ...
    def get_reverse(self) -> bool: ...
    def get_scale(self) -> float: ...
    def get_use_color(self) -> bool: ...
    def has_key(self, key: str) -> bool: ...
    def load_file(self, file_name: str) -> bool: ...
    def load_key_file(
        self, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> bool: ...
    @classmethod
    def new(cls) -> PrintSettings: ...
    @classmethod
    def new_from_file(cls, file_name: str) -> PrintSettings: ...
    @classmethod
    def new_from_gvariant(cls, variant: GLib.Variant) -> PrintSettings: ...
    @classmethod
    def new_from_key_file(
        cls, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> PrintSettings: ...
    def set(self, key: str, value: typing.Optional[str] = None) -> None: ...
    def set_bool(self, key: str, value: bool) -> None: ...
    def set_collate(self, collate: bool) -> None: ...
    def set_default_source(self, default_source: str) -> None: ...
    def set_dither(self, dither: str) -> None: ...
    def set_double(self, key: str, value: float) -> None: ...
    def set_duplex(self, duplex: PrintDuplex) -> None: ...
    def set_finishings(self, finishings: str) -> None: ...
    def set_int(self, key: str, value: int) -> None: ...
    def set_length(self, key: str, value: float, unit: Unit) -> None: ...
    def set_media_type(self, media_type: str) -> None: ...
    def set_n_copies(self, num_copies: int) -> None: ...
    def set_number_up(self, number_up: int) -> None: ...
    def set_number_up_layout(self, number_up_layout: NumberUpLayout) -> None: ...
    def set_orientation(self, orientation: PageOrientation) -> None: ...
    def set_output_bin(self, output_bin: str) -> None: ...
    def set_page_ranges(self, page_ranges: typing.Sequence[PageRange]) -> None: ...
    def set_page_set(self, page_set: PageSet) -> None: ...
    def set_paper_height(self, height: float, unit: Unit) -> None: ...
    def set_paper_size(self, paper_size: PaperSize) -> None: ...
    def set_paper_width(self, width: float, unit: Unit) -> None: ...
    def set_print_pages(self, pages: PrintPages) -> None: ...
    def set_printer(self, printer: str) -> None: ...
    def set_printer_lpi(self, lpi: float) -> None: ...
    def set_quality(self, quality: PrintQuality) -> None: ...
    def set_resolution(self, resolution: int) -> None: ...
    def set_resolution_xy(self, resolution_x: int, resolution_y: int) -> None: ...
    def set_reverse(self, reverse: bool) -> None: ...
    def set_scale(self, scale: float) -> None: ...
    def set_use_color(self, use_color: bool) -> None: ...
    def to_file(self, file_name: str) -> bool: ...
    def to_gvariant(self) -> GLib.Variant: ...
    def to_key_file(
        self, key_file: GLib.KeyFile, group_name: typing.Optional[str] = None
    ) -> None: ...
    def unset(self, key: str) -> None: ...

class PrintSetup(GObject.GBoxed):
    def get_page_setup(self) -> PageSetup: ...
    def get_print_settings(self) -> PrintSettings: ...
    def ref(self) -> PrintSetup: ...
    def unref(self) -> None: ...

class PrintUnixDialog(
    Dialog, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        PrintUnixDialog(**properties)
        new(title:str=None, parent:Gtk.Window=None) -> Gtk.Widget

    Object GtkPrintUnixDialog

    Properties from GtkPrintUnixDialog:
      page-setup -> GtkPageSetup: page-setup
      current-page -> gint: current-page
      print-settings -> GtkPrintSettings: print-settings
      selected-printer -> GtkPrinter: selected-printer
      manual-capabilities -> GtkPrintCapabilities: manual-capabilities
      support-selection -> gboolean: support-selection
      has-selection -> gboolean: has-selection
      embed-page-setup -> gboolean: embed-page-setup

    Signals from GtkDialog:
      response (gint)
      close ()

    Properties from GtkDialog:
      use-header-bar -> gint: use-header-bar

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Dialog.Props):
        current_page: int
        embed_page_setup: bool
        has_selection: bool
        manual_capabilities: PrintCapabilities
        page_setup: PageSetup
        print_settings: PrintSettings
        selected_printer: typing.Optional[Printer]
        support_selection: bool
        use_header_bar: int
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        current_page: int = ...,
        embed_page_setup: bool = ...,
        has_selection: bool = ...,
        manual_capabilities: PrintCapabilities = ...,
        page_setup: PageSetup = ...,
        print_settings: typing.Optional[PrintSettings] = ...,
        support_selection: bool = ...,
        use_header_bar: int = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_custom_tab(self, child: Widget, tab_label: Widget) -> None: ...
    def get_current_page(self) -> int: ...
    def get_embed_page_setup(self) -> bool: ...
    def get_has_selection(self) -> bool: ...
    def get_manual_capabilities(self) -> PrintCapabilities: ...
    def get_page_setup(self) -> PageSetup: ...
    def get_page_setup_set(self) -> bool: ...
    def get_selected_printer(self) -> typing.Optional[Printer]: ...
    def get_settings(self) -> PrintSettings: ...
    def get_support_selection(self) -> bool: ...
    @classmethod
    def new(
        cls, title: typing.Optional[str] = None, parent: typing.Optional[Window] = None
    ) -> PrintUnixDialog: ...
    def set_current_page(self, current_page: int) -> None: ...
    def set_embed_page_setup(self, embed: bool) -> None: ...
    def set_has_selection(self, has_selection: bool) -> None: ...
    def set_manual_capabilities(self, capabilities: PrintCapabilities) -> None: ...
    def set_page_setup(self, page_setup: PageSetup) -> None: ...
    def set_settings(self, settings: typing.Optional[PrintSettings] = None) -> None: ...
    def set_support_selection(self, support_selection: bool) -> None: ...

class Printer(GObject.Object):
    """
    :Constructors:

    ::

        Printer(**properties)
        new(name:str, backend:Gtk.PrintBackend, virtual_:bool) -> Gtk.Printer

    Object GtkPrinter

    Signals from GtkPrinter:
      details-acquired (gboolean)

    Properties from GtkPrinter:
      name -> gchararray: name
      backend -> GtkPrintBackend: backend
      is-virtual -> gboolean: is-virtual
      state-message -> gchararray: state-message
      location -> gchararray: location
      icon-name -> gchararray: icon-name
      job-count -> gint: job-count
      accepts-pdf -> gboolean: accepts-pdf
      accepts-ps -> gboolean: accepts-ps
      paused -> gboolean: paused
      accepting-jobs -> gboolean: accepting-jobs

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        accepting_jobs: bool
        accepts_pdf: bool
        accepts_ps: bool
        icon_name: str
        is_virtual: bool
        job_count: int
        location: str
        name: str
        paused: bool
        state_message: str

    props: Props = ...
    def __init__(
        self,
        accepts_pdf: bool = ...,
        accepts_ps: bool = ...,
        is_virtual: bool = ...,
        name: str = ...,
    ) -> None: ...
    def accepts_pdf(self) -> bool: ...
    def accepts_ps(self) -> bool: ...
    def compare(self, b: Printer) -> int: ...
    def get_backend(self) -> PrintBackend: ...
    def get_capabilities(self) -> PrintCapabilities: ...
    def get_default_page_size(self) -> PageSetup: ...
    def get_description(self) -> str: ...
    def get_hard_margins(self) -> typing.Tuple[bool, float, float, float, float]: ...
    def get_hard_margins_for_paper_size(
        self, paper_size: PaperSize
    ) -> typing.Tuple[bool, float, float, float, float]: ...
    def get_icon_name(self) -> str: ...
    def get_job_count(self) -> int: ...
    def get_location(self) -> str: ...
    def get_name(self) -> str: ...
    def get_state_message(self) -> str: ...
    def has_details(self) -> bool: ...
    def is_accepting_jobs(self) -> bool: ...
    def is_active(self) -> bool: ...
    def is_default(self) -> bool: ...
    def is_paused(self) -> bool: ...
    def is_virtual(self) -> bool: ...
    def list_papers(self) -> list[PageSetup]: ...
    @classmethod
    def new(cls, name: str, backend: PrintBackend, virtual_: bool) -> Printer: ...
    def request_details(self) -> None: ...

class ProgressBar(
    Widget, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        ProgressBar(**properties)
        new() -> Gtk.Widget

    Object GtkProgressBar

    Properties from GtkProgressBar:
      fraction -> gdouble: fraction
      pulse-step -> gdouble: pulse-step
      inverted -> gboolean: inverted
      text -> gchararray: text
      show-text -> gboolean: show-text
      ellipsize -> PangoEllipsizeMode: ellipsize

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        ellipsize: Pango.EllipsizeMode
        fraction: float
        inverted: bool
        pulse_step: float
        show_text: bool
        text: typing.Optional[str]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        ellipsize: Pango.EllipsizeMode = ...,
        fraction: float = ...,
        inverted: bool = ...,
        pulse_step: float = ...,
        show_text: bool = ...,
        text: typing.Optional[str] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_ellipsize(self) -> Pango.EllipsizeMode: ...
    def get_fraction(self) -> float: ...
    def get_inverted(self) -> bool: ...
    def get_pulse_step(self) -> float: ...
    def get_show_text(self) -> bool: ...
    def get_text(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls) -> ProgressBar: ...
    def pulse(self) -> None: ...
    def set_ellipsize(self, mode: Pango.EllipsizeMode) -> None: ...
    def set_fraction(self, fraction: float) -> None: ...
    def set_inverted(self, inverted: bool) -> None: ...
    def set_pulse_step(self, fraction: float) -> None: ...
    def set_show_text(self, show_text: bool) -> None: ...
    def set_text(self, text: typing.Optional[str] = None) -> None: ...

class PropertyExpression(Expression):
    """
    :Constructors:

    ::

        PropertyExpression(**properties)
        new(this_type:GType, expression:Gtk.Expression=None, property_name:str) -> Gtk.PropertyExpression
        new_for_pspec(expression:Gtk.Expression=None, pspec:GObject.ParamSpec) -> Gtk.PropertyExpression
    """
    def get_expression(self) -> typing.Optional[Expression]: ...
    def get_pspec(self) -> GObject.ParamSpec: ...
    @classmethod
    def new(
        cls,
        this_type: typing.Type[typing.Any],
        expression: typing.Optional[Expression],
        property_name: str,
    ) -> PropertyExpression: ...
    @classmethod
    def new_for_pspec(
        cls, expression: typing.Optional[Expression], pspec: GObject.ParamSpec
    ) -> PropertyExpression: ...

class PyGTKDeprecationWarning(gi.PyGIDeprecationWarning): ...

class Range(
    Widget, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        Range(**properties)

    Object GtkRange

    Signals from GtkRange:
      value-changed ()
      adjust-bounds (gdouble)
      move-slider (GtkScrollType)
      change-value (GtkScrollType, gdouble) -> gboolean

    Properties from GtkRange:
      adjustment -> GtkAdjustment: adjustment
      inverted -> gboolean: inverted
      show-fill-level -> gboolean: show-fill-level
      restrict-to-fill-level -> gboolean: restrict-to-fill-level
      fill-level -> gdouble: fill-level
      round-digits -> gint: round-digits

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        adjustment: Adjustment
        fill_level: float
        inverted: bool
        restrict_to_fill_level: bool
        round_digits: int
        show_fill_level: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        adjustment: Adjustment = ...,
        fill_level: float = ...,
        inverted: bool = ...,
        restrict_to_fill_level: bool = ...,
        round_digits: int = ...,
        show_fill_level: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def do_adjust_bounds(self, new_value: float) -> None: ...
    def do_change_value(self, scroll: ScrollType, new_value: float) -> bool: ...
    def do_get_range_border(self, border_: Border) -> None: ...
    def do_move_slider(self, scroll: ScrollType) -> None: ...
    def do_value_changed(self) -> None: ...
    def get_adjustment(self) -> Adjustment: ...
    def get_fill_level(self) -> float: ...
    def get_flippable(self) -> bool: ...
    def get_inverted(self) -> bool: ...
    def get_range_rect(self) -> Gdk.Rectangle: ...
    def get_restrict_to_fill_level(self) -> bool: ...
    def get_round_digits(self) -> int: ...
    def get_show_fill_level(self) -> bool: ...
    def get_slider_range(self) -> typing.Tuple[int, int]: ...
    def get_slider_size_fixed(self) -> bool: ...
    def get_value(self) -> float: ...
    def set_adjustment(self, adjustment: Adjustment) -> None: ...
    def set_fill_level(self, fill_level: float) -> None: ...
    def set_flippable(self, flippable: bool) -> None: ...
    def set_increments(self, step: float, page: float) -> None: ...
    def set_inverted(self, setting: bool) -> None: ...
    def set_range(self, min: float, max: float) -> None: ...
    def set_restrict_to_fill_level(self, restrict_to_fill_level: bool) -> None: ...
    def set_round_digits(self, round_digits: int) -> None: ...
    def set_show_fill_level(self, show_fill_level: bool) -> None: ...
    def set_slider_size_fixed(self, size_fixed: bool) -> None: ...
    def set_value(self, value: float) -> None: ...

class RangeClass(GObject.GPointer):
    """
    :Constructors:

    ::

        RangeClass()
    """

    parent_class: WidgetClass = ...
    value_changed: typing.Callable[[Range], None] = ...
    adjust_bounds: typing.Callable[[Range, float], None] = ...
    move_slider: typing.Callable[[Range, ScrollType], None] = ...
    get_range_border: typing.Callable[[Range, Border], None] = ...
    change_value: typing.Callable[[Range, ScrollType, float], bool] = ...
    padding: list[None] = ...

class RecentData(GObject.GPointer):
    """
    :Constructors:

    ::

        RecentData()
    """

    display_name: str = ...
    description: str = ...
    mime_type: str = ...
    app_name: str = ...
    app_exec: str = ...
    groups: list[str] = ...
    is_private: bool = ...

class RecentInfo(GObject.GBoxed):
    def create_app_info(
        self, app_name: typing.Optional[str] = None
    ) -> typing.Optional[Gio.AppInfo]: ...
    def exists(self) -> bool: ...
    def get_added(self) -> GLib.DateTime: ...
    def get_age(self) -> int: ...
    def get_application_info(
        self, app_name: str
    ) -> typing.Optional[
        typing.Tuple[str, int, GLib.DateTime]
    ]: ...  # CHECK Wrapped function
    def get_applications(self) -> list[str]: ...
    def get_description(self) -> str: ...
    def get_display_name(self) -> str: ...
    def get_gicon(self) -> typing.Optional[Gio.Icon]: ...
    def get_groups(self) -> list[str]: ...
    def get_mime_type(self) -> str: ...
    def get_modified(self) -> GLib.DateTime: ...
    def get_private_hint(self) -> bool: ...
    def get_short_name(self) -> str: ...
    def get_uri(self) -> str: ...
    def get_uri_display(self) -> typing.Optional[str]: ...
    def get_visited(self) -> GLib.DateTime: ...
    def has_application(self, app_name: str) -> bool: ...
    def has_group(self, group_name: str) -> bool: ...
    def is_local(self) -> bool: ...
    def last_application(self) -> str: ...
    def match(self, info_b: RecentInfo) -> bool: ...
    def ref(self) -> RecentInfo: ...
    def unref(self) -> None: ...

class RecentManager(GObject.Object):
    """
    :Constructors:

    ::

        RecentManager(**properties)
        new() -> Gtk.RecentManager

    Object GtkRecentManager

    Signals from GtkRecentManager:
      changed ()

    Properties from GtkRecentManager:
      filename -> gchararray: filename
      size -> gint: size

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        filename: str
        size: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: RecentManagerPrivate = ...
    def __init__(self, filename: str = ...) -> None: ...
    def add_full(self, uri: str, recent_data: RecentData) -> bool: ...
    def add_item(self, uri: str) -> bool: ...
    def do_changed(self) -> None: ...
    @staticmethod
    def get_default() -> RecentManager: ...
    def get_items(self) -> list[RecentInfo]: ...
    def has_item(self, uri: str) -> bool: ...
    def lookup_item(self, uri: str) -> typing.Optional[RecentInfo]: ...
    def move_item(self, uri: str, new_uri: typing.Optional[str] = None) -> bool: ...
    @classmethod
    def new(cls) -> RecentManager: ...
    def purge_items(self) -> int: ...
    def remove_item(self, uri: str) -> bool: ...

class RecentManagerClass(GObject.GPointer):
    """
    :Constructors:

    ::

        RecentManagerClass()
    """

    parent_class: GObject.ObjectClass = ...
    changed: typing.Callable[[RecentManager], None] = ...

class RecentManagerPrivate(GObject.GPointer): ...

class RequestedSize(GObject.GPointer):
    """
    :Constructors:

    ::

        RequestedSize()
    """

    data: None = ...
    minimum_size: int = ...
    natural_size: int = ...

class Requisition(GObject.GBoxed):
    """
    :Constructors:

    ::

        Requisition()
        new() -> Gtk.Requisition
    """

    width: int = ...
    height: int = ...
    def copy(self) -> Requisition: ...
    def free(self) -> None: ...
    @classmethod
    def new(cls) -> Requisition: ...

class Revealer(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Revealer(**properties)
        new() -> Gtk.Widget

    Object GtkRevealer

    Properties from GtkRevealer:
      transition-type -> GtkRevealerTransitionType: transition-type
      transition-duration -> guint: transition-duration
      reveal-child -> gboolean: reveal-child
      child-revealed -> gboolean: child-revealed
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        child_revealed: bool
        reveal_child: bool
        transition_duration: int
        transition_type: RevealerTransitionType
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        reveal_child: bool = ...,
        transition_duration: int = ...,
        transition_type: RevealerTransitionType = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_child_revealed(self) -> bool: ...
    def get_reveal_child(self) -> bool: ...
    def get_transition_duration(self) -> int: ...
    def get_transition_type(self) -> RevealerTransitionType: ...
    @classmethod
    def new(cls) -> Revealer: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_reveal_child(self, reveal_child: bool) -> None: ...
    def set_transition_duration(self, duration: int) -> None: ...
    def set_transition_type(self, transition: RevealerTransitionType) -> None: ...

class Root(GObject.GInterface):
    """
    Interface GtkRoot

    Signals from GObject:
      notify (GParam)
    """
    def get_display(self) -> Gdk.Display: ...
    def get_focus(self) -> typing.Optional[Widget]: ...
    def set_focus(self, focus: typing.Optional[Widget] = None) -> None: ...

class RootInterface(GObject.GPointer): ...

class Scale(
    Range, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        Scale(**properties)
        new(orientation:Gtk.Orientation, adjustment:Gtk.Adjustment=None) -> Gtk.Widget
        new_with_range(orientation:Gtk.Orientation, min:float, max:float, step:float) -> Gtk.Widget

    Object GtkScale

    Properties from GtkScale:
      digits -> gint: digits
      draw-value -> gboolean: draw-value
      has-origin -> gboolean: has-origin
      value-pos -> GtkPositionType: value-pos

    Signals from GtkRange:
      value-changed ()
      adjust-bounds (gdouble)
      move-slider (GtkScrollType)
      change-value (GtkScrollType, gdouble) -> gboolean

    Properties from GtkRange:
      adjustment -> GtkAdjustment: adjustment
      inverted -> gboolean: inverted
      show-fill-level -> gboolean: show-fill-level
      restrict-to-fill-level -> gboolean: restrict-to-fill-level
      fill-level -> gdouble: fill-level
      round-digits -> gint: round-digits

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Range.Props):
        digits: int
        draw_value: bool
        has_origin: bool
        value_pos: PositionType
        adjustment: Adjustment
        fill_level: float
        inverted: bool
        restrict_to_fill_level: bool
        round_digits: int
        show_fill_level: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    parent_instance: Range = ...
    def __init__(
        self,
        digits: int = ...,
        draw_value: bool = ...,
        has_origin: bool = ...,
        value_pos: PositionType = ...,
        adjustment: Adjustment = ...,
        fill_level: float = ...,
        inverted: bool = ...,
        restrict_to_fill_level: bool = ...,
        round_digits: int = ...,
        show_fill_level: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def add_mark(
        self, value: float, position: PositionType, markup: typing.Optional[str] = None
    ) -> None: ...
    def clear_marks(self) -> None: ...
    def do_get_layout_offsets(self) -> typing.Tuple[int, int]: ...
    def get_digits(self) -> int: ...
    def get_draw_value(self) -> bool: ...
    def get_has_origin(self) -> bool: ...
    def get_layout(self) -> typing.Optional[Pango.Layout]: ...
    def get_layout_offsets(self) -> typing.Tuple[int, int]: ...
    def get_value_pos(self) -> PositionType: ...
    @classmethod
    def new(
        cls, orientation: Orientation, adjustment: typing.Optional[Adjustment] = None
    ) -> Scale: ...
    @classmethod
    def new_with_range(
        cls, orientation: Orientation, min: float, max: float, step: float
    ) -> Scale: ...
    def set_digits(self, digits: int) -> None: ...
    def set_draw_value(self, draw_value: bool) -> None: ...
    def set_format_value_func(
        self,
        func: typing.Optional[typing.Callable[..., str]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_has_origin(self, has_origin: bool) -> None: ...
    def set_value_pos(self, pos: PositionType) -> None: ...

class ScaleButton(
    Widget, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        ScaleButton(**properties)
        new(min:float, max:float, step:float, icons:list=None) -> Gtk.Widget

    Object GtkScaleButton

    Signals from GtkScaleButton:
      value-changed (gdouble)
      popup ()
      popdown ()

    Properties from GtkScaleButton:
      value -> gdouble: value
      adjustment -> GtkAdjustment: adjustment
      icons -> GStrv: icons
      active -> gboolean: active
      has-frame -> gboolean: has-frame

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        active: bool
        adjustment: Adjustment
        has_frame: bool
        icons: list[str]
        value: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        adjustment: Adjustment = ...,
        has_frame: bool = ...,
        icons: typing.Sequence[str] = ...,
        value: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def do_value_changed(self, value: float) -> None: ...
    def get_active(self) -> bool: ...
    def get_adjustment(self) -> Adjustment: ...
    def get_has_frame(self) -> bool: ...
    def get_minus_button(self) -> Button: ...
    def get_plus_button(self) -> Button: ...
    def get_popup(self) -> Widget: ...
    def get_value(self) -> float: ...
    @classmethod
    def new(
        cls,
        min: float,
        max: float,
        step: float,
        icons: typing.Optional[typing.Sequence[str]] = None,
    ) -> ScaleButton: ...
    def set_adjustment(self, adjustment: Adjustment) -> None: ...
    def set_has_frame(self, has_frame: bool) -> None: ...
    def set_icons(self, icons: typing.Sequence[str]) -> None: ...
    def set_value(self, value: float) -> None: ...

class ScaleButtonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ScaleButtonClass()
    """

    parent_class: WidgetClass = ...
    value_changed: typing.Callable[[ScaleButton, float], None] = ...
    padding: list[None] = ...

class ScaleClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ScaleClass()
    """

    parent_class: RangeClass = ...
    get_layout_offsets: typing.Callable[[Scale], typing.Tuple[int, int]] = ...
    padding: list[None] = ...

class ScrollInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        new() -> Gtk.ScrollInfo
    """
    def get_enable_horizontal(self) -> bool: ...
    def get_enable_vertical(self) -> bool: ...
    @classmethod
    def new(cls) -> ScrollInfo: ...
    def ref(self) -> ScrollInfo: ...
    def set_enable_horizontal(self, horizontal: bool) -> None: ...
    def set_enable_vertical(self, vertical: bool) -> None: ...
    def unref(self) -> None: ...

class Scrollable(GObject.GInterface):
    """
    Interface GtkScrollable

    Signals from GObject:
      notify (GParam)
    """
    def get_border(self) -> typing.Tuple[bool, Border]: ...
    def get_hadjustment(self) -> typing.Optional[Adjustment]: ...
    def get_hscroll_policy(self) -> ScrollablePolicy: ...
    def get_vadjustment(self) -> typing.Optional[Adjustment]: ...
    def get_vscroll_policy(self) -> ScrollablePolicy: ...
    def set_hadjustment(
        self, hadjustment: typing.Optional[Adjustment] = None
    ) -> None: ...
    def set_hscroll_policy(self, policy: ScrollablePolicy) -> None: ...
    def set_vadjustment(
        self, vadjustment: typing.Optional[Adjustment] = None
    ) -> None: ...
    def set_vscroll_policy(self, policy: ScrollablePolicy) -> None: ...

class ScrollableInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ScrollableInterface()
    """

    base_iface: GObject.TypeInterface = ...
    get_border: typing.Callable[[Scrollable], typing.Tuple[bool, Border]] = ...

class Scrollbar(
    Widget, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        Scrollbar(**properties)
        new(orientation:Gtk.Orientation, adjustment:Gtk.Adjustment=None) -> Gtk.Widget

    Object GtkScrollbar

    Properties from GtkScrollbar:
      adjustment -> GtkAdjustment: adjustment

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        adjustment: Adjustment
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        adjustment: typing.Optional[Adjustment] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_adjustment(self) -> Adjustment: ...
    @classmethod
    def new(
        cls, orientation: Orientation, adjustment: typing.Optional[Adjustment] = None
    ) -> Scrollbar: ...
    def set_adjustment(
        self, adjustment: typing.Optional[Adjustment] = None
    ) -> None: ...

class ScrolledWindow(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ScrolledWindow(**properties)
        new() -> Gtk.Widget

    Object GtkScrolledWindow

    Signals from GtkScrolledWindow:
      move-focus-out (GtkDirectionType)
      scroll-child (GtkScrollType, gboolean) -> gboolean
      edge-overshot (GtkPositionType)
      edge-reached (GtkPositionType)

    Properties from GtkScrolledWindow:
      hadjustment -> GtkAdjustment: hadjustment
      vadjustment -> GtkAdjustment: vadjustment
      hscrollbar-policy -> GtkPolicyType: hscrollbar-policy
      vscrollbar-policy -> GtkPolicyType: vscrollbar-policy
      window-placement -> GtkCornerType: window-placement
      has-frame -> gboolean: has-frame
      min-content-width -> gint: min-content-width
      min-content-height -> gint: min-content-height
      kinetic-scrolling -> gboolean: kinetic-scrolling
      overlay-scrolling -> gboolean: overlay-scrolling
      max-content-width -> gint: max-content-width
      max-content-height -> gint: max-content-height
      propagate-natural-width -> gboolean: propagate-natural-width
      propagate-natural-height -> gboolean: propagate-natural-height
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        hadjustment: Adjustment
        has_frame: bool
        hscrollbar_policy: PolicyType
        kinetic_scrolling: bool
        max_content_height: int
        max_content_width: int
        min_content_height: int
        min_content_width: int
        overlay_scrolling: bool
        propagate_natural_height: bool
        propagate_natural_width: bool
        vadjustment: Adjustment
        vscrollbar_policy: PolicyType
        window_placement: CornerType
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        has_frame: bool = ...,
        hscrollbar_policy: PolicyType = ...,
        kinetic_scrolling: bool = ...,
        max_content_height: int = ...,
        max_content_width: int = ...,
        min_content_height: int = ...,
        min_content_width: int = ...,
        overlay_scrolling: bool = ...,
        propagate_natural_height: bool = ...,
        propagate_natural_width: bool = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscrollbar_policy: PolicyType = ...,
        window_placement: CornerType = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_hadjustment(self) -> Adjustment: ...
    def get_has_frame(self) -> bool: ...
    def get_hscrollbar(self) -> Widget: ...
    def get_kinetic_scrolling(self) -> bool: ...
    def get_max_content_height(self) -> int: ...
    def get_max_content_width(self) -> int: ...
    def get_min_content_height(self) -> int: ...
    def get_min_content_width(self) -> int: ...
    def get_overlay_scrolling(self) -> bool: ...
    def get_placement(self) -> CornerType: ...
    def get_policy(self) -> typing.Tuple[PolicyType, PolicyType]: ...
    def get_propagate_natural_height(self) -> bool: ...
    def get_propagate_natural_width(self) -> bool: ...
    def get_vadjustment(self) -> Adjustment: ...
    def get_vscrollbar(self) -> Widget: ...
    @classmethod
    def new(cls) -> ScrolledWindow: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_hadjustment(
        self, hadjustment: typing.Optional[Adjustment] = None
    ) -> None: ...
    def set_has_frame(self, has_frame: bool) -> None: ...
    def set_kinetic_scrolling(self, kinetic_scrolling: bool) -> None: ...
    def set_max_content_height(self, height: int) -> None: ...
    def set_max_content_width(self, width: int) -> None: ...
    def set_min_content_height(self, height: int) -> None: ...
    def set_min_content_width(self, width: int) -> None: ...
    def set_overlay_scrolling(self, overlay_scrolling: bool) -> None: ...
    def set_placement(self, window_placement: CornerType) -> None: ...
    def set_policy(
        self, hscrollbar_policy: PolicyType, vscrollbar_policy: PolicyType
    ) -> None: ...
    def set_propagate_natural_height(self, propagate: bool) -> None: ...
    def set_propagate_natural_width(self, propagate: bool) -> None: ...
    def set_vadjustment(
        self, vadjustment: typing.Optional[Adjustment] = None
    ) -> None: ...
    def unset_placement(self) -> None: ...

class SearchBar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        SearchBar(**properties)
        new() -> Gtk.Widget

    Object GtkSearchBar

    Properties from GtkSearchBar:
      search-mode-enabled -> gboolean: search-mode-enabled
      show-close-button -> gboolean: show-close-button
      child -> GtkWidget: child
      key-capture-widget -> GtkWidget: key-capture-widget

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        key_capture_widget: typing.Optional[Widget]
        search_mode_enabled: bool
        show_close_button: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        key_capture_widget: typing.Optional[Widget] = ...,
        search_mode_enabled: bool = ...,
        show_close_button: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def connect_entry(self, entry: Editable) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_key_capture_widget(self) -> typing.Optional[Widget]: ...
    def get_search_mode(self) -> bool: ...
    def get_show_close_button(self) -> bool: ...
    @classmethod
    def new(cls) -> SearchBar: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_key_capture_widget(
        self, widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_search_mode(self, search_mode: bool) -> None: ...
    def set_show_close_button(self, visible: bool) -> None: ...

class SearchEntry(Widget, Accessible, Buildable, ConstraintTarget, Editable):
    """
    :Constructors:

    ::

        SearchEntry(**properties)
        new() -> Gtk.Widget

    Object GtkSearchEntry

    Signals from GtkSearchEntry:
      activate ()
      search-changed ()
      next-match ()
      previous-match ()
      stop-search ()
      search-started ()

    Properties from GtkSearchEntry:
      placeholder-text -> gchararray: placeholder-text
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints
      activates-default -> gboolean: activates-default
      search-delay -> guint: search-delay

    Signals from GtkEditable:
      changed ()
      insert-text (gchararray, gint, gpointer)
      delete-text (gint, gint)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activates_default: bool
        input_hints: InputHints
        input_purpose: InputPurpose
        placeholder_text: typing.Optional[str]
        search_delay: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        cursor_position: int
        editable: bool
        enable_undo: bool
        max_width_chars: int
        selection_bound: int
        text: str
        width_chars: int
        xalign: float

    props: Props = ...
    def __init__(
        self,
        activates_default: bool = ...,
        input_hints: InputHints = ...,
        input_purpose: InputPurpose = ...,
        placeholder_text: typing.Optional[str] = ...,
        search_delay: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editable: bool = ...,
        enable_undo: bool = ...,
        max_width_chars: int = ...,
        text: str = ...,
        width_chars: int = ...,
        xalign: float = ...,
    ) -> None: ...
    def get_input_hints(self) -> InputHints: ...
    def get_input_purpose(self) -> InputPurpose: ...
    def get_key_capture_widget(self) -> typing.Optional[Widget]: ...
    def get_placeholder_text(self) -> typing.Optional[str]: ...
    def get_search_delay(self) -> int: ...
    @classmethod
    def new(cls) -> SearchEntry: ...
    def set_input_hints(self, hints: InputHints) -> None: ...
    def set_input_purpose(self, purpose: InputPurpose) -> None: ...
    def set_key_capture_widget(
        self, widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_placeholder_text(self, text: typing.Optional[str] = None) -> None: ...
    def set_search_delay(self, delay: int) -> None: ...

class SectionModel(GObject.GInterface):
    """
    Interface GtkSectionModel

    Signals from GObject:
      notify (GParam)
    """
    def get_section(self, position: int) -> typing.Tuple[int, int]: ...
    def sections_changed(self, position: int, n_items: int) -> None: ...

class SectionModelInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        SectionModelInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_section: typing.Callable[[SectionModel, int], typing.Tuple[int, int]] = ...

# override
class SelectionFilterModel(GObject.Object, Gio.ListModel[typing.Any]):
    """
    :Constructors:

    ::

        SelectionFilterModel(**properties)
        new(model:Gtk.SelectionModel=None) -> Gtk.SelectionFilterModel

    Object GtkSelectionFilterModel

    Properties from GtkSelectionFilterModel:
      item-type -> GType: item-type
      model -> GtkSelectionModel: model
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[typing.Any]
        model: typing.Optional[SelectionModel]
        n_items: int

    props: Props = ...
    def __init__(self, model: typing.Optional[SelectionModel] = ...) -> None: ...
    def get_model(self) -> typing.Optional[SelectionModel]: ...
    @classmethod
    def new(
        cls, model: typing.Optional[SelectionModel] = None
    ) -> SelectionFilterModel: ...
    def set_model(self, model: typing.Optional[SelectionModel] = None) -> None: ...

class SelectionFilterModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SelectionFilterModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class SelectionModel(GObject.GInterface):
    """
    Interface GtkSelectionModel

    Signals from GObject:
      notify (GParam)
    """
    def get_selection(self) -> Bitset: ...
    def get_selection_in_range(self, position: int, n_items: int) -> Bitset: ...
    def is_selected(self, position: int) -> bool: ...
    def select_all(self) -> bool: ...
    def select_item(self, position: int, unselect_rest: bool) -> bool: ...
    def select_range(
        self, position: int, n_items: int, unselect_rest: bool
    ) -> bool: ...
    def selection_changed(self, position: int, n_items: int) -> None: ...
    def set_selection(self, selected: Bitset, mask: Bitset) -> bool: ...
    def unselect_all(self) -> bool: ...
    def unselect_item(self, position: int) -> bool: ...
    def unselect_range(self, position: int, n_items: int) -> bool: ...

class SelectionModelInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        SelectionModelInterface()
    """

    g_iface: GObject.TypeInterface = ...
    is_selected: typing.Callable[[SelectionModel, int], bool] = ...
    get_selection_in_range: typing.Callable[[SelectionModel, int, int], Bitset] = ...
    select_item: typing.Callable[[SelectionModel, int, bool], bool] = ...
    unselect_item: typing.Callable[[SelectionModel, int], bool] = ...
    select_range: typing.Callable[[SelectionModel, int, int, bool], bool] = ...
    unselect_range: typing.Callable[[SelectionModel, int, int], bool] = ...
    select_all: typing.Callable[[SelectionModel], bool] = ...
    unselect_all: typing.Callable[[SelectionModel], bool] = ...
    set_selection: typing.Callable[[SelectionModel, Bitset, Bitset], bool] = ...

class Separator(Widget, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        Separator(**properties)
        new(orientation:Gtk.Orientation) -> Gtk.Widget

    Object GtkSeparator

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    @classmethod
    def new(cls, orientation: Orientation) -> Separator: ...

class Settings(GObject.Object, StyleProvider):
    """
    :Constructors:

    ::

        Settings(**properties)

    Object GtkSettings

    Properties from GtkSettings:
      gtk-double-click-time -> gint: gtk-double-click-time
      gtk-double-click-distance -> gint: gtk-double-click-distance
      gtk-cursor-blink -> gboolean: gtk-cursor-blink
      gtk-cursor-blink-time -> gint: gtk-cursor-blink-time
      gtk-cursor-blink-timeout -> gint: gtk-cursor-blink-timeout
      gtk-split-cursor -> gboolean: gtk-split-cursor
      gtk-cursor-aspect-ratio -> gdouble: gtk-cursor-aspect-ratio
      gtk-theme-name -> gchararray: gtk-theme-name
      gtk-icon-theme-name -> gchararray: gtk-icon-theme-name
      gtk-dnd-drag-threshold -> gint: gtk-dnd-drag-threshold
      gtk-font-name -> gchararray: gtk-font-name
      gtk-xft-antialias -> gint: gtk-xft-antialias
      gtk-xft-hinting -> gint: gtk-xft-hinting
      gtk-xft-hintstyle -> gchararray: gtk-xft-hintstyle
      gtk-xft-rgba -> gchararray: gtk-xft-rgba
      gtk-xft-dpi -> gint: gtk-xft-dpi
      gtk-hint-font-metrics -> gboolean: gtk-hint-font-metrics
      gtk-cursor-theme-name -> gchararray: gtk-cursor-theme-name
      gtk-cursor-theme-size -> gint: gtk-cursor-theme-size
      gtk-alternative-button-order -> gboolean: gtk-alternative-button-order
      gtk-alternative-sort-arrows -> gboolean: gtk-alternative-sort-arrows
      gtk-enable-animations -> gboolean: gtk-enable-animations
      gtk-error-bell -> gboolean: gtk-error-bell
      gtk-show-status-shapes -> gboolean: gtk-show-status-shapes
      gtk-print-backends -> gchararray: gtk-print-backends
      gtk-print-preview-command -> gchararray: gtk-print-preview-command
      gtk-enable-accels -> gboolean: gtk-enable-accels
      gtk-im-module -> gchararray: gtk-im-module
      gtk-recent-files-max-age -> gint: gtk-recent-files-max-age
      gtk-fontconfig-timestamp -> guint: gtk-fontconfig-timestamp
      gtk-sound-theme-name -> gchararray: gtk-sound-theme-name
      gtk-enable-input-feedback-sounds -> gboolean: gtk-enable-input-feedback-sounds
      gtk-enable-event-sounds -> gboolean: gtk-enable-event-sounds
      gtk-primary-button-warps-slider -> gboolean: gtk-primary-button-warps-slider
      gtk-application-prefer-dark-theme -> gboolean: gtk-application-prefer-dark-theme
      gtk-entry-select-on-focus -> gboolean: gtk-entry-select-on-focus
      gtk-entry-password-hint-timeout -> guint: gtk-entry-password-hint-timeout
      gtk-label-select-on-focus -> gboolean: gtk-label-select-on-focus
      gtk-shell-shows-app-menu -> gboolean: gtk-shell-shows-app-menu
      gtk-shell-shows-menubar -> gboolean: gtk-shell-shows-menubar
      gtk-shell-shows-desktop -> gboolean: gtk-shell-shows-desktop
      gtk-decoration-layout -> gchararray: gtk-decoration-layout
      gtk-titlebar-double-click -> gchararray: gtk-titlebar-double-click
      gtk-titlebar-middle-click -> gchararray: gtk-titlebar-middle-click
      gtk-titlebar-right-click -> gchararray: gtk-titlebar-right-click
      gtk-dialogs-use-header -> gboolean: gtk-dialogs-use-header
      gtk-enable-primary-paste -> gboolean: gtk-enable-primary-paste
      gtk-recent-files-enabled -> gboolean: gtk-recent-files-enabled
      gtk-long-press-time -> guint: gtk-long-press-time
      gtk-keynav-use-caret -> gboolean: gtk-keynav-use-caret
      gtk-overlay-scrolling -> gboolean: gtk-overlay-scrolling
      gtk-font-rendering -> GtkFontRendering: gtk-font-rendering
      gtk-interface-color-scheme -> GtkInterfaceColorScheme: gtk-interface-color-scheme
      gtk-interface-contrast -> GtkInterfaceContrast: gtk-interface-contrast

    Signals from GtkStyleProvider:
      gtk-private-changed ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        gtk_alternative_button_order: bool
        gtk_alternative_sort_arrows: bool
        gtk_application_prefer_dark_theme: bool
        gtk_cursor_aspect_ratio: float
        gtk_cursor_blink: bool
        gtk_cursor_blink_time: int
        gtk_cursor_blink_timeout: int
        gtk_cursor_theme_name: str
        gtk_cursor_theme_size: int
        gtk_decoration_layout: str
        gtk_dialogs_use_header: bool
        gtk_dnd_drag_threshold: int
        gtk_double_click_distance: int
        gtk_double_click_time: int
        gtk_enable_accels: bool
        gtk_enable_animations: bool
        gtk_enable_event_sounds: bool
        gtk_enable_input_feedback_sounds: bool
        gtk_enable_primary_paste: bool
        gtk_entry_password_hint_timeout: int
        gtk_entry_select_on_focus: bool
        gtk_error_bell: bool
        gtk_font_name: str
        gtk_font_rendering: FontRendering
        gtk_fontconfig_timestamp: int
        gtk_hint_font_metrics: bool
        gtk_icon_theme_name: str
        gtk_im_module: str
        gtk_interface_color_scheme: InterfaceColorScheme
        gtk_interface_contrast: InterfaceContrast
        gtk_keynav_use_caret: bool
        gtk_label_select_on_focus: bool
        gtk_long_press_time: int
        gtk_overlay_scrolling: bool
        gtk_primary_button_warps_slider: bool
        gtk_print_backends: str
        gtk_print_preview_command: str
        gtk_recent_files_enabled: bool
        gtk_recent_files_max_age: int
        gtk_shell_shows_app_menu: bool
        gtk_shell_shows_desktop: bool
        gtk_shell_shows_menubar: bool
        gtk_show_status_shapes: bool
        gtk_sound_theme_name: str
        gtk_split_cursor: bool
        gtk_theme_name: str
        gtk_titlebar_double_click: str
        gtk_titlebar_middle_click: str
        gtk_titlebar_right_click: str
        gtk_xft_antialias: int
        gtk_xft_dpi: int
        gtk_xft_hinting: int
        gtk_xft_hintstyle: str
        gtk_xft_rgba: str

    props: Props = ...
    def __init__(
        self,
        gtk_alternative_button_order: bool = ...,
        gtk_alternative_sort_arrows: bool = ...,
        gtk_application_prefer_dark_theme: bool = ...,
        gtk_cursor_aspect_ratio: float = ...,
        gtk_cursor_blink: bool = ...,
        gtk_cursor_blink_time: int = ...,
        gtk_cursor_blink_timeout: int = ...,
        gtk_cursor_theme_name: str = ...,
        gtk_cursor_theme_size: int = ...,
        gtk_decoration_layout: str = ...,
        gtk_dialogs_use_header: bool = ...,
        gtk_dnd_drag_threshold: int = ...,
        gtk_double_click_distance: int = ...,
        gtk_double_click_time: int = ...,
        gtk_enable_accels: bool = ...,
        gtk_enable_animations: bool = ...,
        gtk_enable_event_sounds: bool = ...,
        gtk_enable_input_feedback_sounds: bool = ...,
        gtk_enable_primary_paste: bool = ...,
        gtk_entry_password_hint_timeout: int = ...,
        gtk_entry_select_on_focus: bool = ...,
        gtk_error_bell: bool = ...,
        gtk_font_name: str = ...,
        gtk_font_rendering: FontRendering = ...,
        gtk_fontconfig_timestamp: int = ...,
        gtk_hint_font_metrics: bool = ...,
        gtk_icon_theme_name: str = ...,
        gtk_im_module: str = ...,
        gtk_interface_color_scheme: InterfaceColorScheme = ...,
        gtk_interface_contrast: InterfaceContrast = ...,
        gtk_keynav_use_caret: bool = ...,
        gtk_label_select_on_focus: bool = ...,
        gtk_long_press_time: int = ...,
        gtk_overlay_scrolling: bool = ...,
        gtk_primary_button_warps_slider: bool = ...,
        gtk_print_backends: str = ...,
        gtk_print_preview_command: str = ...,
        gtk_recent_files_enabled: bool = ...,
        gtk_recent_files_max_age: int = ...,
        gtk_shell_shows_app_menu: bool = ...,
        gtk_shell_shows_desktop: bool = ...,
        gtk_shell_shows_menubar: bool = ...,
        gtk_show_status_shapes: bool = ...,
        gtk_sound_theme_name: str = ...,
        gtk_split_cursor: bool = ...,
        gtk_theme_name: str = ...,
        gtk_titlebar_double_click: str = ...,
        gtk_titlebar_middle_click: str = ...,
        gtk_titlebar_right_click: str = ...,
        gtk_xft_antialias: int = ...,
        gtk_xft_dpi: int = ...,
        gtk_xft_hinting: int = ...,
        gtk_xft_hintstyle: str = ...,
        gtk_xft_rgba: str = ...,
    ) -> None: ...
    @staticmethod
    def get_default() -> typing.Optional[Settings]: ...
    @staticmethod
    def get_for_display(display: Gdk.Display) -> Settings: ...
    def reset_property(self, name: str) -> None: ...

class Shortcut(GObject.Object):
    """
    :Constructors:

    ::

        Shortcut(**properties)
        new(trigger:Gtk.ShortcutTrigger=None, action:Gtk.ShortcutAction=None) -> Gtk.Shortcut

    Object GtkShortcut

    Properties from GtkShortcut:
      action -> GtkShortcutAction: action
      arguments -> GVariant: arguments
      trigger -> GtkShortcutTrigger: trigger

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        action: typing.Optional[ShortcutAction]
        arguments: typing.Optional[GLib.Variant]
        trigger: typing.Optional[ShortcutTrigger]

    props: Props = ...
    def __init__(
        self,
        action: typing.Optional[ShortcutAction] = ...,
        arguments: typing.Optional[GLib.Variant] = ...,
        trigger: typing.Optional[ShortcutTrigger] = ...,
    ) -> None: ...
    def get_action(self) -> typing.Optional[ShortcutAction]: ...
    def get_arguments(self) -> typing.Optional[GLib.Variant]: ...
    def get_trigger(self) -> typing.Optional[ShortcutTrigger]: ...
    @classmethod
    def new(
        cls,
        trigger: typing.Optional[ShortcutTrigger] = None,
        action: typing.Optional[ShortcutAction] = None,
    ) -> Shortcut: ...
    def set_action(self, action: typing.Optional[ShortcutAction] = None) -> None: ...
    def set_arguments(self, args: typing.Optional[GLib.Variant] = None) -> None: ...
    def set_trigger(self, trigger: typing.Optional[ShortcutTrigger] = None) -> None: ...

class ShortcutAction(GObject.Object):
    """
    :Constructors:

    ::

        ShortcutAction(**properties)
        parse_string(string:str) -> Gtk.ShortcutAction or None

    Object GtkShortcutAction

    Signals from GObject:
      notify (GParam)
    """
    def activate(
        self,
        flags: ShortcutActionFlags,
        widget: Widget,
        args: typing.Optional[GLib.Variant] = None,
    ) -> bool: ...
    @classmethod
    def parse_string(cls, string: str) -> typing.Optional[ShortcutAction]: ...
    def print_(self, string: GLib.String) -> None: ...
    def to_string(self) -> str: ...

class ShortcutActionClass(GObject.GPointer): ...

class ShortcutClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ShortcutClass()
    """

    parent_class: GObject.ObjectClass = ...

# override
class ShortcutController(EventController, Gio.ListModel[typing.Any], Buildable):
    """
    :Constructors:

    ::

        ShortcutController(**properties)
        new() -> Gtk.EventController
        new_for_model(model:Gio.ListModel) -> Gtk.EventController

    Object GtkShortcutController

    Properties from GtkShortcutController:
      item-type -> GType: item-type
      mnemonic-modifiers -> GdkModifierType: mnemonic-modifiers
      model -> GListModel: model
      n-items -> guint: n-items
      scope -> GtkShortcutScope: scope

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Properties from GtkEventController:
      widget -> GtkWidget: widget
      propagation-phase -> GtkPropagationPhase: propagation-phase
      propagation-limit -> GtkPropagationLimit: propagation-limit
      name -> gchararray: name

    Signals from GObject:
      notify (GParam)
    """
    class Props(EventController.Props):
        item_type: typing.Type[typing.Any]
        mnemonic_modifiers: Gdk.ModifierType
        n_items: int
        scope: ShortcutScope
        name: typing.Optional[str]
        propagation_limit: PropagationLimit
        propagation_phase: PropagationPhase
        widget: typing.Optional[Widget]
        model: Gio.ListModel[typing.Any]

    props: Props = ...
    def __init__(
        self,
        mnemonic_modifiers: Gdk.ModifierType = ...,
        model: Gio.ListModel[typing.Any] = ...,
        scope: ShortcutScope = ...,
        name: typing.Optional[str] = ...,
        propagation_limit: PropagationLimit = ...,
        propagation_phase: PropagationPhase = ...,
    ) -> None: ...
    def add_shortcut(self, shortcut: Shortcut) -> None: ...
    def get_mnemonics_modifiers(self) -> Gdk.ModifierType: ...
    def get_scope(self) -> ShortcutScope: ...
    @classmethod
    def new(cls) -> ShortcutController: ...
    @classmethod
    def new_for_model(cls, model: Gio.ListModel[typing.Any]) -> ShortcutController: ...
    def remove_shortcut(self, shortcut: Shortcut) -> None: ...
    def set_mnemonics_modifiers(self, modifiers: Gdk.ModifierType) -> None: ...
    def set_scope(self, scope: ShortcutScope) -> None: ...

class ShortcutControllerClass(GObject.GPointer): ...

class ShortcutLabel(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ShortcutLabel(**properties)
        new(accelerator:str) -> Gtk.Widget

    Object GtkShortcutLabel

    Properties from GtkShortcutLabel:
      accelerator -> gchararray: accelerator
      disabled-text -> gchararray: disabled-text

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        accelerator: typing.Optional[str]
        disabled_text: typing.Optional[str]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        accelerator: str = ...,
        disabled_text: str = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_accelerator(self) -> typing.Optional[str]: ...
    def get_disabled_text(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls, accelerator: str) -> ShortcutLabel: ...
    def set_accelerator(self, accelerator: str) -> None: ...
    def set_disabled_text(self, disabled_text: str) -> None: ...

class ShortcutLabelClass(GObject.GPointer): ...
class ShortcutManager(GObject.GInterface): ...

class ShortcutManagerInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ShortcutManagerInterface()
    """

    g_iface: GObject.TypeInterface = ...
    add_controller: typing.Callable[[ShortcutManager, ShortcutController], None] = ...
    remove_controller: typing.Callable[
        [ShortcutManager, ShortcutController], None
    ] = ...

class ShortcutTrigger(GObject.Object):
    """
    :Constructors:

    ::

        ShortcutTrigger(**properties)
        parse_string(string:str) -> Gtk.ShortcutTrigger or None

    Object GtkShortcutTrigger

    Signals from GObject:
      notify (GParam)
    """
    def compare(self, trigger2: ShortcutTrigger) -> int: ...
    def equal(self, trigger2: ShortcutTrigger) -> bool: ...
    def hash(self) -> int: ...
    @classmethod
    def parse_string(cls, string: str) -> typing.Optional[ShortcutTrigger]: ...
    def print_(self, string: GLib.String) -> None: ...
    def print_label(self, display: Gdk.Display, string: GLib.String) -> bool: ...
    def to_label(self, display: Gdk.Display) -> str: ...
    def to_string(self) -> str: ...
    def trigger(self, event: Gdk.Event, enable_mnemonics: bool) -> Gdk.KeyMatch: ...

class ShortcutTriggerClass(GObject.GPointer): ...

class ShortcutsGroup(Box, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        ShortcutsGroup(**properties)

    Object GtkShortcutsGroup

    Properties from GtkShortcutsGroup:
      title -> gchararray: title
      view -> gchararray: view
      accel-size-group -> GtkSizeGroup: accel-size-group
      title-size-group -> GtkSizeGroup: title-size-group
      height -> guint: height

    Properties from GtkBox:
      spacing -> gint: spacing
      homogeneous -> gboolean: homogeneous
      baseline-child -> gint: baseline-child
      baseline-position -> GtkBaselinePosition: baseline-position

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Box.Props):
        height: int
        title: str
        view: str
        baseline_child: int
        baseline_position: BaselinePosition
        homogeneous: bool
        spacing: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation
        accel_size_group: SizeGroup
        title_size_group: SizeGroup

    props: Props = ...
    def __init__(
        self,
        accel_size_group: SizeGroup = ...,
        title: str = ...,
        title_size_group: SizeGroup = ...,
        view: str = ...,
        baseline_child: int = ...,
        baseline_position: BaselinePosition = ...,
        homogeneous: bool = ...,
        spacing: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def add_shortcut(self, shortcut: ShortcutsShortcut) -> None: ...

class ShortcutsGroupClass(GObject.GPointer): ...

class ShortcutsSection(Box, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        ShortcutsSection(**properties)

    Object GtkShortcutsSection

    Signals from GtkShortcutsSection:
      change-current-page (gint) -> gboolean

    Properties from GtkShortcutsSection:
      title -> gchararray: title
      section-name -> gchararray: section-name
      view-name -> gchararray: view-name
      max-height -> guint: max-height

    Properties from GtkBox:
      spacing -> gint: spacing
      homogeneous -> gboolean: homogeneous
      baseline-child -> gint: baseline-child
      baseline-position -> GtkBaselinePosition: baseline-position

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Box.Props):
        max_height: int
        section_name: str
        title: str
        view_name: str
        baseline_child: int
        baseline_position: BaselinePosition
        homogeneous: bool
        spacing: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        max_height: int = ...,
        section_name: str = ...,
        title: str = ...,
        view_name: str = ...,
        baseline_child: int = ...,
        baseline_position: BaselinePosition = ...,
        homogeneous: bool = ...,
        spacing: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def add_group(self, group: ShortcutsGroup) -> None: ...

class ShortcutsSectionClass(GObject.GPointer): ...

class ShortcutsShortcut(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ShortcutsShortcut(**properties)

    Object GtkShortcutsShortcut

    Properties from GtkShortcutsShortcut:
      accelerator -> gchararray: accelerator
      icon -> GIcon: icon
      icon-set -> gboolean: icon-set
      title -> gchararray: title
      subtitle -> gchararray: subtitle
      subtitle-set -> gboolean: subtitle-set
      accel-size-group -> GtkSizeGroup: accel-size-group
      title-size-group -> GtkSizeGroup: title-size-group
      direction -> GtkTextDirection: direction
      shortcut-type -> GtkShortcutType: shortcut-type
      action-name -> gchararray: action-name

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        accelerator: str
        action_name: str
        direction: TextDirection
        icon: Gio.Icon
        icon_set: bool
        shortcut_type: ShortcutType
        subtitle: str
        subtitle_set: bool
        title: str
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        accel_size_group: SizeGroup
        title_size_group: SizeGroup

    props: Props = ...
    def __init__(
        self,
        accel_size_group: SizeGroup = ...,
        accelerator: str = ...,
        action_name: str = ...,
        direction: TextDirection = ...,
        icon: Gio.Icon = ...,
        icon_set: bool = ...,
        shortcut_type: ShortcutType = ...,
        subtitle: str = ...,
        subtitle_set: bool = ...,
        title: str = ...,
        title_size_group: SizeGroup = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...

class ShortcutsShortcutClass(GObject.GPointer): ...

class ShortcutsWindow(
    Window, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        ShortcutsWindow(**properties)

    Object GtkShortcutsWindow

    Signals from GtkShortcutsWindow:
      close ()
      search ()

    Properties from GtkShortcutsWindow:
      section-name -> gchararray: section-name
      view-name -> gchararray: view-name

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Window.Props):
        section_name: str
        view_name: str
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    def __init__(
        self,
        section_name: str = ...,
        view_name: str = ...,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_section(self, section: ShortcutsSection) -> None: ...

class SignalAction(ShortcutAction):
    """
    :Constructors:

    ::

        SignalAction(**properties)
        new(signal_name:str) -> Gtk.SignalAction

    Object GtkSignalAction

    Properties from GtkSignalAction:
      signal-name -> gchararray: signal-name

    Signals from GObject:
      notify (GParam)
    """
    class Props(ShortcutAction.Props):
        signal_name: str

    props: Props = ...
    def __init__(self, signal_name: str = ...) -> None: ...
    def get_signal_name(self) -> str: ...
    @classmethod
    def new(cls, signal_name: str) -> SignalAction: ...

class SignalActionClass(GObject.GPointer): ...

class SignalListItemFactory(ListItemFactory):
    """
    :Constructors:

    ::

        SignalListItemFactory(**properties)
        new() -> Gtk.ListItemFactory

    Object GtkSignalListItemFactory

    Signals from GtkSignalListItemFactory:
      setup (GObject)
      bind (GObject)
      unbind (GObject)
      teardown (GObject)

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(cls) -> SignalListItemFactory: ...

class SignalListItemFactoryClass(GObject.GPointer): ...

# override
class SingleSelection(
    GObject.Object, Gio.ListModel[typing.Any], SectionModel, SelectionModel
):
    """
    :Constructors:

    ::

        SingleSelection(**properties)
        new(model:Gio.ListModel=None) -> Gtk.SingleSelection

    Object GtkSingleSelection

    Properties from GtkSingleSelection:
      autoselect -> gboolean: autoselect
      can-unselect -> gboolean: can-unselect
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items
      selected -> guint: selected
      selected-item -> GObject: selected-item

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GtkSelectionModel:
      selection-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        autoselect: bool
        can_unselect: bool
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int
        selected: int
        selected_item: typing.Optional[GObject.Object]

    props: Props = ...
    def __init__(
        self,
        autoselect: bool = ...,
        can_unselect: bool = ...,
        model: typing.Optional[Gio.ListModel[typing.Any]] = ...,
        selected: int = ...,
    ) -> None: ...
    def get_autoselect(self) -> bool: ...
    def get_can_unselect(self) -> bool: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_selected(self) -> int: ...
    def get_selected_item(self) -> typing.Optional[GObject.Object]: ...
    @classmethod
    def new(
        cls, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> SingleSelection: ...
    def set_autoselect(self, autoselect: bool) -> None: ...
    def set_can_unselect(self, can_unselect: bool) -> None: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...
    def set_selected(self, position: int) -> None: ...

class SingleSelectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SingleSelectionClass()
    """

    parent_class: GObject.ObjectClass = ...

class SizeGroup(GObject.Object, Buildable):
    """
    :Constructors:

    ::

        SizeGroup(**properties)
        new(mode:Gtk.SizeGroupMode) -> Gtk.SizeGroup

    Object GtkSizeGroup

    Properties from GtkSizeGroup:
      mode -> GtkSizeGroupMode: mode

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        mode: SizeGroupMode

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(self, mode: SizeGroupMode = ...) -> None: ...
    def add_widget(self, widget: Widget) -> None: ...
    def get_mode(self) -> SizeGroupMode: ...
    def get_widgets(self) -> list[Widget]: ...
    @classmethod
    def new(cls, mode: SizeGroupMode) -> SizeGroup: ...
    def remove_widget(self, widget: Widget) -> None: ...
    def set_mode(self, mode: SizeGroupMode) -> None: ...

# override
class SliceListModel(GObject.Object, Gio.ListModel[typing.Any], SectionModel):
    """
    :Constructors:

    ::

        SliceListModel(**properties)
        new(model:Gio.ListModel=None, offset:int, size:int) -> Gtk.SliceListModel

    Object GtkSliceListModel

    Properties from GtkSliceListModel:
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items
      offset -> guint: offset
      size -> guint: size

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int
        offset: int
        size: int

    props: Props = ...
    def __init__(
        self,
        model: typing.Optional[Gio.ListModel[typing.Any]] = ...,
        offset: int = ...,
        size: int = ...,
    ) -> None: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_offset(self) -> int: ...
    def get_size(self) -> int: ...
    @classmethod
    def new(
        cls, model: typing.Optional[Gio.ListModel[typing.Any]], offset: int, size: int
    ) -> SliceListModel: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...
    def set_offset(self, offset: int) -> None: ...
    def set_size(self, size: int) -> None: ...

class SliceListModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SliceListModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class Snapshot(Gdk.Snapshot):
    """
    :Constructors:

    ::

        Snapshot(**properties)
        new() -> Gtk.Snapshot

    Object GtkSnapshot

    Signals from GObject:
      notify (GParam)
    """
    def append_border(
        self,
        outline: Gsk.RoundedRect,
        border_width: typing.Sequence[float],
        border_color: typing.Sequence[Gdk.RGBA],
    ) -> None: ...
    def append_cairo(self, bounds: Graphene.Rect) -> cairo.Context: ...
    def append_color(self, color: Gdk.RGBA, bounds: Graphene.Rect) -> None: ...
    def append_conic_gradient(
        self,
        bounds: Graphene.Rect,
        center: Graphene.Point,
        rotation: float,
        stops: typing.Sequence[Gsk.ColorStop],
    ) -> None: ...
    def append_fill(
        self, path: Gsk.Path, fill_rule: Gsk.FillRule, color: Gdk.RGBA
    ) -> None: ...
    def append_inset_shadow(
        self,
        outline: Gsk.RoundedRect,
        color: Gdk.RGBA,
        dx: float,
        dy: float,
        spread: float,
        blur_radius: float,
    ) -> None: ...
    def append_layout(self, layout: Pango.Layout, color: Gdk.RGBA) -> None: ...
    def append_linear_gradient(
        self,
        bounds: Graphene.Rect,
        start_point: Graphene.Point,
        end_point: Graphene.Point,
        stops: typing.Sequence[Gsk.ColorStop],
    ) -> None: ...
    def append_node(self, node: Gsk.RenderNode) -> None: ...
    def append_outset_shadow(
        self,
        outline: Gsk.RoundedRect,
        color: Gdk.RGBA,
        dx: float,
        dy: float,
        spread: float,
        blur_radius: float,
    ) -> None: ...
    def append_radial_gradient(
        self,
        bounds: Graphene.Rect,
        center: Graphene.Point,
        hradius: float,
        vradius: float,
        start: float,
        end: float,
        stops: typing.Sequence[Gsk.ColorStop],
    ) -> None: ...
    def append_repeating_linear_gradient(
        self,
        bounds: Graphene.Rect,
        start_point: Graphene.Point,
        end_point: Graphene.Point,
        stops: typing.Sequence[Gsk.ColorStop],
    ) -> None: ...
    def append_repeating_radial_gradient(
        self,
        bounds: Graphene.Rect,
        center: Graphene.Point,
        hradius: float,
        vradius: float,
        start: float,
        end: float,
        stops: typing.Sequence[Gsk.ColorStop],
    ) -> None: ...
    def append_scaled_texture(
        self, texture: Gdk.Texture, filter: Gsk.ScalingFilter, bounds: Graphene.Rect
    ) -> None: ...
    def append_stroke(
        self, path: Gsk.Path, stroke: Gsk.Stroke, color: Gdk.RGBA
    ) -> None: ...
    def append_texture(self, texture: Gdk.Texture, bounds: Graphene.Rect) -> None: ...
    def gl_shader_pop_texture(self) -> None: ...
    @classmethod
    def new(cls) -> Snapshot: ...
    def perspective(self, depth: float) -> None: ...
    def pop(self) -> None: ...
    def push_blend(self, blend_mode: Gsk.BlendMode) -> None: ...
    def push_blur(self, radius: float) -> None: ...
    def push_clip(self, bounds: Graphene.Rect) -> None: ...
    def push_color_matrix(
        self, color_matrix: Graphene.Matrix, color_offset: Graphene.Vec4
    ) -> None: ...
    def push_component_transfer(
        self,
        red: Gsk.ComponentTransfer,
        green: Gsk.ComponentTransfer,
        blue: Gsk.ComponentTransfer,
        alpha: Gsk.ComponentTransfer,
    ) -> None: ...
    def push_cross_fade(self, progress: float) -> None: ...
    def push_fill(self, path: Gsk.Path, fill_rule: Gsk.FillRule) -> None: ...
    def push_gl_shader(
        self, shader: Gsk.GLShader, bounds: Graphene.Rect, take_args: GLib.Bytes
    ) -> None: ...
    def push_mask(self, mask_mode: Gsk.MaskMode) -> None: ...
    def push_opacity(self, opacity: float) -> None: ...
    def push_repeat(
        self, bounds: Graphene.Rect, child_bounds: typing.Optional[Graphene.Rect] = None
    ) -> None: ...
    def push_rounded_clip(self, bounds: Gsk.RoundedRect) -> None: ...
    def push_shadow(self, shadow: typing.Sequence[Gsk.Shadow]) -> None: ...
    def push_stroke(self, path: Gsk.Path, stroke: Gsk.Stroke) -> None: ...
    def render_background(
        self, context: StyleContext, x: float, y: float, width: float, height: float
    ) -> None: ...
    def render_focus(
        self, context: StyleContext, x: float, y: float, width: float, height: float
    ) -> None: ...
    def render_frame(
        self, context: StyleContext, x: float, y: float, width: float, height: float
    ) -> None: ...
    def render_insertion_cursor(
        self,
        context: StyleContext,
        x: float,
        y: float,
        layout: Pango.Layout,
        index: int,
        direction: Pango.Direction,
    ) -> None: ...
    def render_layout(
        self, context: StyleContext, x: float, y: float, layout: Pango.Layout
    ) -> None: ...
    def restore(self) -> None: ...
    def rotate(self, angle: float) -> None: ...
    def rotate_3d(self, angle: float, axis: Graphene.Vec3) -> None: ...
    def save(self) -> None: ...
    def scale(self, factor_x: float, factor_y: float) -> None: ...
    def scale_3d(self, factor_x: float, factor_y: float, factor_z: float) -> None: ...
    def to_node(self) -> typing.Optional[Gsk.RenderNode]: ...
    def to_paintable(
        self, size: typing.Optional[Graphene.Size] = None
    ) -> typing.Optional[Gdk.Paintable]: ...
    def transform(self, transform: typing.Optional[Gsk.Transform] = None) -> None: ...
    def transform_matrix(self, matrix: Graphene.Matrix) -> None: ...
    def translate(self, point: Graphene.Point) -> None: ...
    def translate_3d(self, point: Graphene.Point3D) -> None: ...

class SnapshotClass(GObject.GPointer): ...

# override
class SortListModel(GObject.Object, Gio.ListModel[typing.Any], SectionModel):
    """
    :Constructors:

    ::

        SortListModel(**properties)
        new(model:Gio.ListModel=None, sorter:Gtk.Sorter=None) -> Gtk.SortListModel

    Object GtkSortListModel

    Properties from GtkSortListModel:
      incremental -> gboolean: incremental
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items
      pending -> guint: pending
      section-sorter -> GtkSorter: section-sorter
      sorter -> GtkSorter: sorter

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GtkSectionModel:
      sections-changed (guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        incremental: bool
        item_type: typing.Type[typing.Any]
        model: typing.Optional[Gio.ListModel[typing.Any]]
        n_items: int
        pending: int
        section_sorter: typing.Optional[Sorter]
        sorter: typing.Optional[Sorter]

    props: Props = ...
    def __init__(
        self,
        incremental: bool = ...,
        model: typing.Optional[Gio.ListModel[typing.Any]] = ...,
        section_sorter: typing.Optional[Sorter] = ...,
        sorter: typing.Optional[Sorter] = ...,
    ) -> None: ...
    def get_incremental(self) -> bool: ...
    def get_model(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_pending(self) -> int: ...
    def get_section_sorter(self) -> typing.Optional[Sorter]: ...
    def get_sorter(self) -> typing.Optional[Sorter]: ...
    @classmethod
    def new(
        cls,
        model: typing.Optional[Gio.ListModel[typing.Any]] = None,
        sorter: typing.Optional[Sorter] = None,
    ) -> SortListModel: ...
    def set_incremental(self, incremental: bool) -> None: ...
    def set_model(
        self, model: typing.Optional[Gio.ListModel[typing.Any]] = None
    ) -> None: ...
    def set_section_sorter(self, sorter: typing.Optional[Sorter] = None) -> None: ...
    def set_sorter(self, sorter: typing.Optional[Sorter] = None) -> None: ...

class SortListModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SortListModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class Sorter(GObject.Object):
    """
    :Constructors:

    ::

        Sorter(**properties)

    Object GtkSorter

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    def changed(self, change: SorterChange) -> None: ...
    def compare(self, item1: GObject.Object, item2: GObject.Object) -> Ordering: ...
    def do_compare(
        self,
        item1: typing.Optional[GObject.Object] = None,
        item2: typing.Optional[GObject.Object] = None,
    ) -> Ordering: ...
    def do_get_order(self) -> SorterOrder: ...
    def get_order(self) -> SorterOrder: ...

class SorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SorterClass()
    """

    parent_class: GObject.ObjectClass = ...
    compare: typing.Callable[
        [Sorter, typing.Optional[GObject.Object], typing.Optional[GObject.Object]],
        Ordering,
    ] = ...
    get_order: typing.Callable[[Sorter], SorterOrder] = ...

class SpinButton(
    Widget,
    Accessible,
    AccessibleRange,
    Buildable,
    CellEditable,
    ConstraintTarget,
    Editable,
    Orientable,
):
    """
    :Constructors:

    ::

        SpinButton(**properties)
        new(adjustment:Gtk.Adjustment=None, climb_rate:float, digits:int) -> Gtk.Widget
        new_with_range(min:float, max:float, step:float) -> Gtk.Widget

    Object GtkSpinButton

    Signals from GtkSpinButton:
      value-changed ()
      activate ()
      change-value (GtkScrollType)
      input (gpointer) -> gint
      output () -> gboolean
      wrapped ()

    Properties from GtkSpinButton:
      activates-default -> gboolean: activates-default
      adjustment -> GtkAdjustment: adjustment
      climb-rate -> gdouble: climb-rate
      digits -> guint: digits
      snap-to-ticks -> gboolean: snap-to-ticks
      numeric -> gboolean: numeric
      wrap -> gboolean: wrap
      update-policy -> GtkSpinButtonUpdatePolicy: update-policy
      value -> gdouble: value

    Signals from GtkEditable:
      changed ()
      insert-text (gchararray, gint, gpointer)
      delete-text (gint, gint)

    Signals from GtkCellEditable:
      editing-done ()
      remove-widget ()

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activates_default: bool
        adjustment: Adjustment
        climb_rate: float
        digits: int
        numeric: bool
        snap_to_ticks: bool
        update_policy: SpinButtonUpdatePolicy
        value: float
        wrap: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        editing_canceled: bool
        cursor_position: int
        editable: bool
        enable_undo: bool
        max_width_chars: int
        selection_bound: int
        text: str
        width_chars: int
        xalign: float
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        activates_default: bool = ...,
        adjustment: Adjustment = ...,
        climb_rate: float = ...,
        digits: int = ...,
        numeric: bool = ...,
        snap_to_ticks: bool = ...,
        update_policy: SpinButtonUpdatePolicy = ...,
        value: float = ...,
        wrap: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editing_canceled: bool = ...,
        editable: bool = ...,
        enable_undo: bool = ...,
        max_width_chars: int = ...,
        text: str = ...,
        width_chars: int = ...,
        xalign: float = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def configure(
        self, adjustment: typing.Optional[Adjustment], climb_rate: float, digits: int
    ) -> None: ...
    def get_activates_default(self) -> bool: ...
    def get_adjustment(self) -> Adjustment: ...
    def get_climb_rate(self) -> float: ...
    def get_digits(self) -> int: ...
    def get_increments(self) -> typing.Tuple[float, float]: ...
    def get_numeric(self) -> bool: ...
    def get_range(self) -> typing.Tuple[float, float]: ...
    def get_snap_to_ticks(self) -> bool: ...
    def get_update_policy(self) -> SpinButtonUpdatePolicy: ...
    def get_value(self) -> float: ...
    def get_value_as_int(self) -> int: ...
    def get_wrap(self) -> bool: ...
    @classmethod
    def new(
        cls, adjustment: typing.Optional[Adjustment], climb_rate: float, digits: int
    ) -> SpinButton: ...
    @classmethod
    def new_with_range(cls, min: float, max: float, step: float) -> SpinButton: ...
    def set_activates_default(self, activates_default: bool) -> None: ...
    def set_adjustment(self, adjustment: Adjustment) -> None: ...
    def set_climb_rate(self, climb_rate: float) -> None: ...
    def set_digits(self, digits: int) -> None: ...
    def set_increments(self, step: float, page: float) -> None: ...
    def set_numeric(self, numeric: bool) -> None: ...
    def set_range(self, min: float, max: float) -> None: ...
    def set_snap_to_ticks(self, snap_to_ticks: bool) -> None: ...
    def set_update_policy(self, policy: SpinButtonUpdatePolicy) -> None: ...
    def set_value(self, value: float) -> None: ...
    def set_wrap(self, wrap: bool) -> None: ...
    def spin(self, direction: SpinType, increment: float) -> None: ...
    def update(self) -> None: ...

class Spinner(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Spinner(**properties)
        new() -> Gtk.Widget

    Object GtkSpinner

    Properties from GtkSpinner:
      spinning -> gboolean: spinning

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        spinning: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        spinning: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_spinning(self) -> bool: ...
    @classmethod
    def new(cls) -> Spinner: ...
    def set_spinning(self, spinning: bool) -> None: ...
    def start(self) -> None: ...
    def stop(self) -> None: ...

class Stack(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Stack(**properties)
        new() -> Gtk.Widget

    Object GtkStack

    Properties from GtkStack:
      hhomogeneous -> gboolean: hhomogeneous
      vhomogeneous -> gboolean: vhomogeneous
      visible-child -> GtkWidget: visible-child
      visible-child-name -> gchararray: visible-child-name
      transition-duration -> guint: transition-duration
      transition-type -> GtkStackTransitionType: transition-type
      transition-running -> gboolean: transition-running
      interpolate-size -> gboolean: interpolate-size
      pages -> GtkSelectionModel: pages

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        hhomogeneous: bool
        interpolate_size: bool
        pages: SelectionModel
        transition_duration: int
        transition_running: bool
        transition_type: StackTransitionType
        vhomogeneous: bool
        visible_child: typing.Optional[Widget]
        visible_child_name: typing.Optional[str]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        hhomogeneous: bool = ...,
        interpolate_size: bool = ...,
        transition_duration: int = ...,
        transition_type: StackTransitionType = ...,
        vhomogeneous: bool = ...,
        visible_child: Widget = ...,
        visible_child_name: str = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def add_child(self, child: Widget) -> StackPage: ...
    def add_named(
        self, child: Widget, name: typing.Optional[str] = None
    ) -> StackPage: ...
    def add_titled(
        self, child: Widget, name: typing.Optional[str], title: str
    ) -> StackPage: ...
    def get_child_by_name(self, name: str) -> typing.Optional[Widget]: ...
    def get_hhomogeneous(self) -> bool: ...
    def get_interpolate_size(self) -> bool: ...
    def get_page(self, child: Widget) -> StackPage: ...
    def get_pages(self) -> SelectionModel: ...
    def get_transition_duration(self) -> int: ...
    def get_transition_running(self) -> bool: ...
    def get_transition_type(self) -> StackTransitionType: ...
    def get_vhomogeneous(self) -> bool: ...
    def get_visible_child(self) -> typing.Optional[Widget]: ...
    def get_visible_child_name(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls) -> Stack: ...
    def remove(self, child: Widget) -> None: ...
    def set_hhomogeneous(self, hhomogeneous: bool) -> None: ...
    def set_interpolate_size(self, interpolate_size: bool) -> None: ...
    def set_transition_duration(self, duration: int) -> None: ...
    def set_transition_type(self, transition: StackTransitionType) -> None: ...
    def set_vhomogeneous(self, vhomogeneous: bool) -> None: ...
    def set_visible_child(self, child: Widget) -> None: ...
    def set_visible_child_full(
        self, name: str, transition: StackTransitionType
    ) -> None: ...
    def set_visible_child_name(self, name: str) -> None: ...

class StackPage(GObject.Object, Accessible):
    """
    :Constructors:

    ::

        StackPage(**properties)

    Object GtkStackPage

    Properties from GtkStackPage:
      child -> GtkWidget: child
      name -> gchararray: name
      title -> gchararray: title
      icon-name -> gchararray: icon-name
      needs-attention -> gboolean: needs-attention
      visible -> gboolean: visible
      use-underline -> gboolean: use-underline

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        child: Widget
        icon_name: typing.Optional[str]
        name: typing.Optional[str]
        needs_attention: bool
        title: typing.Optional[str]
        use_underline: bool
        visible: bool
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: Widget = ...,
        icon_name: str = ...,
        name: str = ...,
        needs_attention: bool = ...,
        title: str = ...,
        use_underline: bool = ...,
        visible: bool = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> Widget: ...
    def get_icon_name(self) -> typing.Optional[str]: ...
    def get_name(self) -> typing.Optional[str]: ...
    def get_needs_attention(self) -> bool: ...
    def get_title(self) -> typing.Optional[str]: ...
    def get_use_underline(self) -> bool: ...
    def get_visible(self) -> bool: ...
    def set_icon_name(self, setting: str) -> None: ...
    def set_name(self, setting: str) -> None: ...
    def set_needs_attention(self, setting: bool) -> None: ...
    def set_title(self, setting: str) -> None: ...
    def set_use_underline(self, setting: bool) -> None: ...
    def set_visible(self, visible: bool) -> None: ...

class StackSidebar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        StackSidebar(**properties)
        new() -> Gtk.Widget

    Object GtkStackSidebar

    Properties from GtkStackSidebar:
      stack -> GtkStack: stack

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        stack: typing.Optional[Stack]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        stack: Stack = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_stack(self) -> typing.Optional[Stack]: ...
    @classmethod
    def new(cls) -> StackSidebar: ...
    def set_stack(self, stack: Stack) -> None: ...

class StackSwitcher(Widget, Accessible, Buildable, ConstraintTarget, Orientable):
    """
    :Constructors:

    ::

        StackSwitcher(**properties)
        new() -> Gtk.Widget

    Object GtkStackSwitcher

    Properties from GtkStackSwitcher:
      stack -> GtkStack: stack

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        stack: typing.Optional[Stack]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    def __init__(
        self,
        stack: typing.Optional[Stack] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    def get_stack(self) -> typing.Optional[Stack]: ...
    @classmethod
    def new(cls) -> StackSwitcher: ...
    def set_stack(self, stack: typing.Optional[Stack] = None) -> None: ...

class Statusbar(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Statusbar(**properties)
        new() -> Gtk.Widget

    Object GtkStatusbar

    Signals from GtkStatusbar:
      text-pushed (guint, gchararray)
      text-popped (guint, gchararray)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_context_id(self, context_description: str) -> int: ...
    @classmethod
    def new(cls) -> Statusbar: ...
    def pop(self, context_id: int) -> None: ...
    def push(self, context_id: int, text: str) -> int: ...
    def remove(self, context_id: int, message_id: int) -> None: ...
    def remove_all(self, context_id: int) -> None: ...

class StringFilter(Filter):
    """
    :Constructors:

    ::

        StringFilter(**properties)
        new(expression:Gtk.Expression=None) -> Gtk.StringFilter

    Object GtkStringFilter

    Properties from GtkStringFilter:
      expression -> GtkExpression: expression
      ignore-case -> gboolean: ignore-case
      match-mode -> GtkStringFilterMatchMode: match-mode
      search -> gchararray: search

    Signals from GtkFilter:
      changed (GtkFilterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Filter.Props):
        expression: typing.Optional[Expression]
        ignore_case: bool
        match_mode: StringFilterMatchMode
        search: typing.Optional[str]

    props: Props = ...
    def __init__(
        self,
        expression: typing.Optional[Expression] = ...,
        ignore_case: bool = ...,
        match_mode: StringFilterMatchMode = ...,
        search: typing.Optional[str] = ...,
    ) -> None: ...
    def get_expression(self) -> typing.Optional[Expression]: ...
    def get_ignore_case(self) -> bool: ...
    def get_match_mode(self) -> StringFilterMatchMode: ...
    def get_search(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls, expression: typing.Optional[Expression] = None) -> StringFilter: ...
    def set_expression(
        self, expression: typing.Optional[Expression] = None
    ) -> None: ...
    def set_ignore_case(self, ignore_case: bool) -> None: ...
    def set_match_mode(self, mode: StringFilterMatchMode) -> None: ...
    def set_search(self, search: typing.Optional[str] = None) -> None: ...

class StringFilterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        StringFilterClass()
    """

    parent_class: FilterClass = ...

# override
class StringList(GObject.Object, Gio.ListModel[typing.Any], Buildable):
    """
    :Constructors:

    ::

        StringList(**properties)
        new(strings:list=None) -> Gtk.StringList

    Object GtkStringList

    Properties from GtkStringList:
      item-type -> GType: item-type
      n-items -> guint: n-items
      strings -> GStrv: strings

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[typing.Any]
        n_items: int
        strings: list[str]

    props: Props = ...
    def __init__(self, strings: typing.Sequence[str] = ...) -> None: ...
    def append(self, string: str) -> None: ...
    def find(self, string: str) -> int: ...
    def get_string(self, position: int) -> typing.Optional[str]: ...
    @classmethod
    def new(
        cls, strings: typing.Optional[typing.Sequence[str]] = None
    ) -> StringList: ...
    def remove(self, position: int) -> None: ...
    def splice(
        self,
        position: int,
        n_removals: int,
        additions: typing.Optional[typing.Sequence[str]] = None,
    ) -> None: ...
    def take(self, string: str) -> None: ...

class StringListClass(GObject.GPointer):
    """
    :Constructors:

    ::

        StringListClass()
    """

    parent_class: GObject.ObjectClass = ...

class StringObject(GObject.Object):
    """
    :Constructors:

    ::

        StringObject(**properties)
        new(string:str) -> Gtk.StringObject

    Object GtkStringObject

    Properties from GtkStringObject:
      string -> gchararray: string

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        string: str

    props: Props = ...
    def get_string(self) -> str: ...
    @classmethod
    def new(cls, string: str) -> StringObject: ...

class StringObjectClass(GObject.GPointer):
    """
    :Constructors:

    ::

        StringObjectClass()
    """

    parent_class: GObject.ObjectClass = ...

class StringSorter(Sorter):
    """
    :Constructors:

    ::

        StringSorter(**properties)
        new(expression:Gtk.Expression=None) -> Gtk.StringSorter

    Object GtkStringSorter

    Properties from GtkStringSorter:
      expression -> GtkExpression: expression
      ignore-case -> gboolean: ignore-case
      collation -> GtkCollation: collation

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Sorter.Props):
        collation: Collation
        expression: typing.Optional[Expression]
        ignore_case: bool

    props: Props = ...
    def __init__(
        self,
        collation: Collation = ...,
        expression: typing.Optional[Expression] = ...,
        ignore_case: bool = ...,
    ) -> None: ...
    def get_collation(self) -> Collation: ...
    def get_expression(self) -> typing.Optional[Expression]: ...
    def get_ignore_case(self) -> bool: ...
    @classmethod
    def new(cls, expression: typing.Optional[Expression] = None) -> StringSorter: ...
    def set_collation(self, collation: Collation) -> None: ...
    def set_expression(
        self, expression: typing.Optional[Expression] = None
    ) -> None: ...
    def set_ignore_case(self, ignore_case: bool) -> None: ...

class StringSorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        StringSorterClass()
    """

    parent_class: SorterClass = ...

class StyleContext(GObject.Object):
    """
    :Constructors:

    ::

        StyleContext(**properties)

    Object GtkStyleContext

    Properties from GtkStyleContext:
      display -> GdkDisplay: display

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        display: Gdk.Display

    props: Props = ...
    parent_object: GObject.Object = ...
    def __init__(self, display: Gdk.Display = ...) -> None: ...
    def add_class(self, class_name: str) -> None: ...
    def add_provider(self, provider: StyleProvider, priority: int) -> None: ...
    @staticmethod
    def add_provider_for_display(
        display: Gdk.Display, provider: StyleProvider, priority: int
    ) -> None: ...
    def do_changed(self) -> None: ...
    def get_border(self) -> Border: ...
    def get_color(self) -> Gdk.RGBA: ...
    def get_display(self) -> Gdk.Display: ...
    def get_margin(self) -> Border: ...
    def get_padding(self) -> Border: ...
    def get_scale(self) -> int: ...
    def get_state(self) -> StateFlags: ...
    def has_class(self, class_name: str) -> bool: ...
    def lookup_color(self, color_name: str) -> typing.Tuple[bool, Gdk.RGBA]: ...
    def remove_class(self, class_name: str) -> None: ...
    def remove_provider(self, provider: StyleProvider) -> None: ...
    @staticmethod
    def remove_provider_for_display(
        display: Gdk.Display, provider: StyleProvider
    ) -> None: ...
    def restore(self) -> None: ...
    def save(self) -> None: ...
    def set_display(self, display: Gdk.Display) -> None: ...
    def set_scale(self, scale: int) -> None: ...
    def set_state(self, flags: StateFlags) -> None: ...
    def to_string(self, flags: StyleContextPrintFlags) -> str: ...

class StyleContextClass(GObject.GPointer):
    """
    :Constructors:

    ::

        StyleContextClass()
    """

    parent_class: GObject.ObjectClass = ...
    changed: typing.Callable[[StyleContext], None] = ...

class StyleProvider(GObject.GInterface): ...

class Switch(Widget, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Switch(**properties)
        new() -> Gtk.Widget

    Object GtkSwitch

    Signals from GtkSwitch:
      activate ()
      state-set (gboolean) -> gboolean

    Properties from GtkSwitch:
      active -> gboolean: active
      state -> gboolean: state

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        active: bool
        state: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant

    props: Props = ...
    def __init__(
        self,
        active: bool = ...,
        state: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def get_active(self) -> bool: ...
    def get_state(self) -> bool: ...
    @classmethod
    def new(cls) -> Switch: ...
    def set_active(self, is_active: bool) -> None: ...
    def set_state(self, state: bool) -> None: ...

class SymbolicPaintable(GObject.GInterface):
    """
    Interface GtkSymbolicPaintable

    Signals from GObject:
      notify (GParam)
    """
    def snapshot_symbolic(
        self,
        snapshot: Gdk.Snapshot,
        width: float,
        height: float,
        colors: typing.Sequence[Gdk.RGBA],
    ) -> None: ...

class SymbolicPaintableInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        SymbolicPaintableInterface()
    """

    g_iface: GObject.TypeInterface = ...
    snapshot_symbolic: typing.Callable[
        [SymbolicPaintable, Gdk.Snapshot, float, float, typing.Sequence[Gdk.RGBA]], None
    ] = ...

# override
class Template:
    def __init__(
        self,
        filename: str | os.PathLike[str] = ...,
        resource_path: str = ...,
        string: str | bytes = ...,
    ) -> None: ...
    @classmethod
    def from_file(cls, filename: str | os.PathLike[str]) -> Template: ...
    @classmethod
    def from_resource(cls, resource_path: str) -> Template: ...
    @classmethod
    def from_string(cls, string: str | bytes) -> Template: ...
    def __call__(self, cls: T) -> T: ...

    class Callback:
        def __init__(self, name: str | None = ...) -> None: ...
        def __call__(self, func: typing.Callable[..., typing.Any]) -> typing.Any: ...

    @classmethod
    def Child(cls: typing.Any, name: str | None = ...) -> typing.Any: ...

class Text(Widget, Accessible, AccessibleText, Buildable, ConstraintTarget, Editable):
    """
    :Constructors:

    ::

        Text(**properties)
        new() -> Gtk.Widget
        new_with_buffer(buffer:Gtk.EntryBuffer) -> Gtk.Widget

    Object GtkText

    Signals from GtkText:
      activate ()
      move-cursor (GtkMovementStep, gint, gboolean)
      preedit-changed (gchararray)
      copy-clipboard ()
      insert-at-cursor (gchararray)
      delete-from-cursor (GtkDeleteType, gint)
      backspace ()
      cut-clipboard ()
      paste-clipboard ()
      toggle-overwrite ()
      insert-emoji ()

    Properties from GtkText:
      buffer -> GtkEntryBuffer: buffer
      max-length -> gint: max-length
      visibility -> gboolean: visibility
      invisible-char -> guint: invisible-char
      invisible-char-set -> gboolean: invisible-char-set
      activates-default -> gboolean: activates-default
      scroll-offset -> gint: scroll-offset
      truncate-multiline -> gboolean: truncate-multiline
      overwrite-mode -> gboolean: overwrite-mode
      im-module -> gchararray: im-module
      placeholder-text -> gchararray: placeholder-text
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints
      attributes -> PangoAttrList: attributes
      tabs -> PangoTabArray: tabs
      enable-emoji-completion -> gboolean: enable-emoji-completion
      propagate-text-width -> gboolean: propagate-text-width
      extra-menu -> GMenuModel: extra-menu

    Signals from GtkEditable:
      changed ()
      insert-text (gchararray, gint, gpointer)
      delete-text (gint, gint)

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activates_default: bool
        attributes: typing.Optional[Pango.AttrList]
        buffer: EntryBuffer
        enable_emoji_completion: bool
        extra_menu: typing.Optional[Gio.MenuModel]
        im_module: str
        input_hints: InputHints
        input_purpose: InputPurpose
        invisible_char: int
        invisible_char_set: bool
        max_length: int
        overwrite_mode: bool
        placeholder_text: typing.Optional[str]
        propagate_text_width: bool
        scroll_offset: int
        tabs: typing.Optional[Pango.TabArray]
        truncate_multiline: bool
        visibility: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        cursor_position: int
        editable: bool
        enable_undo: bool
        max_width_chars: int
        selection_bound: int
        text: str
        width_chars: int
        xalign: float

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        activates_default: bool = ...,
        attributes: typing.Optional[Pango.AttrList] = ...,
        buffer: EntryBuffer = ...,
        enable_emoji_completion: bool = ...,
        extra_menu: typing.Optional[Gio.MenuModel] = ...,
        im_module: str = ...,
        input_hints: InputHints = ...,
        input_purpose: InputPurpose = ...,
        invisible_char: int = ...,
        invisible_char_set: bool = ...,
        max_length: int = ...,
        overwrite_mode: bool = ...,
        placeholder_text: typing.Optional[str] = ...,
        propagate_text_width: bool = ...,
        tabs: typing.Optional[Pango.TabArray] = ...,
        truncate_multiline: bool = ...,
        visibility: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        editable: bool = ...,
        enable_undo: bool = ...,
        max_width_chars: int = ...,
        text: str = ...,
        width_chars: int = ...,
        xalign: float = ...,
    ) -> None: ...
    def compute_cursor_extents(
        self, position: int
    ) -> typing.Tuple[Graphene.Rect, Graphene.Rect]: ...
    def get_activates_default(self) -> bool: ...
    def get_attributes(self) -> typing.Optional[Pango.AttrList]: ...
    def get_buffer(self) -> EntryBuffer: ...
    def get_enable_emoji_completion(self) -> bool: ...
    def get_extra_menu(self) -> typing.Optional[Gio.MenuModel]: ...
    def get_input_hints(self) -> InputHints: ...
    def get_input_purpose(self) -> InputPurpose: ...
    def get_invisible_char(self) -> str: ...
    def get_max_length(self) -> int: ...
    def get_overwrite_mode(self) -> bool: ...
    def get_placeholder_text(self) -> typing.Optional[str]: ...
    def get_propagate_text_width(self) -> bool: ...
    def get_tabs(self) -> typing.Optional[Pango.TabArray]: ...
    def get_text_length(self) -> int: ...
    def get_truncate_multiline(self) -> bool: ...
    def get_visibility(self) -> bool: ...
    def grab_focus_without_selecting(self) -> bool: ...
    @classmethod
    def new(cls) -> Text: ...
    @classmethod
    def new_with_buffer(cls, buffer: EntryBuffer) -> Text: ...
    def set_activates_default(self, activates: bool) -> None: ...
    def set_attributes(self, attrs: typing.Optional[Pango.AttrList] = None) -> None: ...
    def set_buffer(self, buffer: EntryBuffer) -> None: ...
    def set_enable_emoji_completion(self, enable_emoji_completion: bool) -> None: ...
    def set_extra_menu(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def set_input_hints(self, hints: InputHints) -> None: ...
    def set_input_purpose(self, purpose: InputPurpose) -> None: ...
    def set_invisible_char(self, ch: str) -> None: ...
    def set_max_length(self, length: int) -> None: ...
    def set_overwrite_mode(self, overwrite: bool) -> None: ...
    def set_placeholder_text(self, text: typing.Optional[str] = None) -> None: ...
    def set_propagate_text_width(self, propagate_text_width: bool) -> None: ...
    def set_tabs(self, tabs: typing.Optional[Pango.TabArray] = None) -> None: ...
    def set_truncate_multiline(self, truncate_multiline: bool) -> None: ...
    def set_visibility(self, visible: bool) -> None: ...
    def unset_invisible_char(self) -> None: ...

class TextBuffer(GObject.Object):
    """
    :Constructors:

    ::

        TextBuffer(**properties)
        new(table:Gtk.TextTagTable=None) -> Gtk.TextBuffer

    Object GtkTextBuffer

    Signals from GtkTextBuffer:
      changed ()
      insert-text (GtkTextIter, gchararray, gint)
      insert-paintable (GtkTextIter, GdkPaintable)
      insert-child-anchor (GtkTextIter, GtkTextChildAnchor)
      delete-range (GtkTextIter, GtkTextIter)
      modified-changed ()
      mark-set (GtkTextIter, GtkTextMark)
      mark-deleted (GtkTextMark)
      apply-tag (GtkTextTag, GtkTextIter, GtkTextIter)
      remove-tag (GtkTextTag, GtkTextIter, GtkTextIter)
      begin-user-action ()
      end-user-action ()
      paste-done (GdkClipboard)
      redo ()
      undo ()

    Properties from GtkTextBuffer:
      tag-table -> GtkTextTagTable: tag-table
      text -> gchararray: text
      has-selection -> gboolean: has-selection
      cursor-position -> gint: cursor-position
      can-undo -> gboolean: can-undo
      can-redo -> gboolean: can-redo
      enable-undo -> gboolean: enable-undo

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        can_redo: bool
        can_undo: bool
        cursor_position: int
        enable_undo: bool
        has_selection: bool
        tag_table: TextTagTable
        text: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: TextBufferPrivate = ...
    def __init__(
        self, enable_undo: bool = ..., tag_table: TextTagTable = ..., text: str = ...
    ) -> None: ...
    def add_commit_notify(
        self,
        flags: TextBufferNotifyFlags,
        commit_notify: typing.Callable[..., None],
        *user_data: typing.Any,
    ) -> int: ...
    def add_mark(self, mark: TextMark, where: TextIter) -> None: ...
    def add_selection_clipboard(self, clipboard: Gdk.Clipboard) -> None: ...
    def apply_tag(self, tag: TextTag, start: TextIter, end: TextIter) -> None: ...
    def apply_tag_by_name(self, name: str, start: TextIter, end: TextIter) -> None: ...
    def backspace(
        self, iter: TextIter, interactive: bool, default_editable: bool
    ) -> bool: ...
    def begin_irreversible_action(self) -> None: ...
    def begin_user_action(self) -> None: ...
    def copy_clipboard(self, clipboard: Gdk.Clipboard) -> None: ...
    def create_child_anchor(self, iter: TextIter) -> TextChildAnchor: ...
    # override
    def create_mark(
        self,
        mark_name: typing.Optional[str],
        where: TextIter,
        left_gravity: bool = False,
    ) -> TextMark: ...
    # override
    def create_tag(
        self, tag_name: typing.Optional[str] = None, **properties: typing.Any
    ) -> TextTag: ...
    def cut_clipboard(
        self, clipboard: Gdk.Clipboard, default_editable: bool
    ) -> None: ...
    def delete(self, start: TextIter, end: TextIter) -> None: ...
    def delete_interactive(
        self, start_iter: TextIter, end_iter: TextIter, default_editable: bool
    ) -> bool: ...
    def delete_mark(self, mark: TextMark) -> None: ...
    def delete_mark_by_name(self, name: str) -> None: ...
    def delete_selection(self, interactive: bool, default_editable: bool) -> bool: ...
    def do_apply_tag(self, tag: TextTag, start: TextIter, end: TextIter) -> None: ...
    def do_begin_user_action(self) -> None: ...
    def do_changed(self) -> None: ...
    def do_delete_range(self, start: TextIter, end: TextIter) -> None: ...
    def do_end_user_action(self) -> None: ...
    def do_insert_child_anchor(
        self, iter: TextIter, anchor: TextChildAnchor
    ) -> None: ...
    def do_insert_paintable(self, iter: TextIter, paintable: Gdk.Paintable) -> None: ...
    def do_insert_text(
        self, pos: TextIter, new_text: str, new_text_length: int
    ) -> None: ...
    def do_mark_deleted(self, mark: TextMark) -> None: ...
    def do_mark_set(self, location: TextIter, mark: TextMark) -> None: ...
    def do_modified_changed(self) -> None: ...
    def do_paste_done(self, clipboard: Gdk.Clipboard) -> None: ...
    def do_redo(self) -> None: ...
    def do_remove_tag(self, tag: TextTag, start: TextIter, end: TextIter) -> None: ...
    def do_undo(self) -> None: ...
    def end_irreversible_action(self) -> None: ...
    def end_user_action(self) -> None: ...
    def get_bounds(self) -> typing.Tuple[TextIter, TextIter]: ...
    def get_can_redo(self) -> bool: ...
    def get_can_undo(self) -> bool: ...
    def get_char_count(self) -> int: ...
    def get_enable_undo(self) -> bool: ...
    def get_end_iter(self) -> TextIter: ...
    def get_has_selection(self) -> bool: ...
    def get_insert(self) -> TextMark: ...
    def get_iter_at_child_anchor(self, anchor: TextChildAnchor) -> TextIter: ...
    def get_iter_at_line(self, line_number: int) -> typing.Tuple[bool, TextIter]: ...
    def get_iter_at_line_index(
        self, line_number: int, byte_index: int
    ) -> typing.Tuple[bool, TextIter]: ...
    def get_iter_at_line_offset(
        self, line_number: int, char_offset: int
    ) -> typing.Tuple[bool, TextIter]: ...
    def get_iter_at_mark(self, mark: TextMark) -> TextIter: ...
    def get_iter_at_offset(self, char_offset: int) -> TextIter: ...
    def get_line_count(self) -> int: ...
    def get_mark(self, name: str) -> typing.Optional[TextMark]: ...
    def get_max_undo_levels(self) -> int: ...
    def get_modified(self) -> bool: ...
    def get_selection_bound(self) -> TextMark: ...
    def get_selection_bounds(
        self,
    ) -> (
        typing.Tuple[TextIter, TextIter] | typing.Tuple[()]
    ): ...  # CHECK Wrapped function
    def get_selection_content(self) -> Gdk.ContentProvider: ...
    def get_slice(
        self, start: TextIter, end: TextIter, include_hidden_chars: bool
    ) -> str: ...
    def get_start_iter(self) -> TextIter: ...
    def get_tag_table(self) -> TextTagTable: ...
    def get_text(
        self, start: TextIter, end: TextIter, include_hidden_chars: bool
    ) -> str: ...
    # override
    def insert(self, iter: TextIter, text: str, length: int = ...) -> None: ...
    # override
    def insert_at_cursor(self, text: str, length: int = ...) -> None: ...
    def insert_child_anchor(self, iter: TextIter, anchor: TextChildAnchor) -> None: ...
    def insert_interactive(
        self, iter: TextIter, text: str, len: int, default_editable: bool
    ) -> bool: ...
    def insert_interactive_at_cursor(
        self, text: str, len: int, default_editable: bool
    ) -> bool: ...
    def insert_markup(self, iter: TextIter, markup: str, len: int) -> None: ...
    def insert_paintable(self, iter: TextIter, paintable: Gdk.Paintable) -> None: ...
    def insert_range(self, iter: TextIter, start: TextIter, end: TextIter) -> None: ...
    def insert_range_interactive(
        self, iter: TextIter, start: TextIter, end: TextIter, default_editable: bool
    ) -> bool: ...
    def insert_with_tags(
        self, iter, text, *tags
    ): ...  # FIXME: Override is missing typing annotation
    # override
    def insert_with_tags_by_name(
        self, iter: TextIter, text: str, *tags: typing.Any
    ) -> None: ...
    def move_mark(self, mark: TextMark, where: TextIter) -> None: ...
    def move_mark_by_name(self, name: str, where: TextIter) -> None: ...
    @classmethod
    def new(cls, table: typing.Optional[TextTagTable] = None) -> TextBuffer: ...
    def paste_clipboard(
        self,
        clipboard: Gdk.Clipboard,
        override_location: typing.Optional[TextIter],
        default_editable: bool,
    ) -> None: ...
    def place_cursor(self, where: TextIter) -> None: ...
    def redo(self) -> None: ...
    def remove_all_tags(self, start: TextIter, end: TextIter) -> None: ...
    def remove_commit_notify(self, commit_notify_handler: int) -> None: ...
    def remove_selection_clipboard(self, clipboard: Gdk.Clipboard) -> None: ...
    def remove_tag(self, tag: TextTag, start: TextIter, end: TextIter) -> None: ...
    def remove_tag_by_name(self, name: str, start: TextIter, end: TextIter) -> None: ...
    def select_range(self, ins: TextIter, bound: TextIter) -> None: ...
    def set_enable_undo(self, enable_undo: bool) -> None: ...
    def set_max_undo_levels(self, max_undo_levels: int) -> None: ...
    def set_modified(self, setting: bool) -> None: ...
    # override
    def set_text(self, text: str, len: int = -1) -> None: ...
    def undo(self) -> None: ...

class TextBufferClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TextBufferClass()
    """

    parent_class: GObject.ObjectClass = ...
    insert_text: typing.Callable[[TextBuffer, TextIter, str, int], None] = ...
    insert_paintable: typing.Callable[[TextBuffer, TextIter, Gdk.Paintable], None] = ...
    insert_child_anchor: typing.Callable[
        [TextBuffer, TextIter, TextChildAnchor], None
    ] = ...
    delete_range: typing.Callable[[TextBuffer, TextIter, TextIter], None] = ...
    changed: typing.Callable[[TextBuffer], None] = ...
    modified_changed: typing.Callable[[TextBuffer], None] = ...
    mark_set: typing.Callable[[TextBuffer, TextIter, TextMark], None] = ...
    mark_deleted: typing.Callable[[TextBuffer, TextMark], None] = ...
    apply_tag: typing.Callable[[TextBuffer, TextTag, TextIter, TextIter], None] = ...
    remove_tag: typing.Callable[[TextBuffer, TextTag, TextIter, TextIter], None] = ...
    begin_user_action: typing.Callable[[TextBuffer], None] = ...
    end_user_action: typing.Callable[[TextBuffer], None] = ...
    paste_done: typing.Callable[[TextBuffer, Gdk.Clipboard], None] = ...
    undo: typing.Callable[[TextBuffer], None] = ...
    redo: typing.Callable[[TextBuffer], None] = ...

class TextBufferPrivate(GObject.GPointer): ...

class TextChildAnchor(GObject.Object):
    """
    :Constructors:

    ::

        TextChildAnchor(**properties)
        new() -> Gtk.TextChildAnchor
        new_with_replacement(character:str) -> Gtk.TextChildAnchor

    Object GtkTextChildAnchor

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    segment: None = ...
    def get_deleted(self) -> bool: ...
    def get_widgets(self) -> list[Widget]: ...
    @classmethod
    def new(cls) -> TextChildAnchor: ...
    @classmethod
    def new_with_replacement(cls, character: str) -> TextChildAnchor: ...

class TextChildAnchorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TextChildAnchorClass()
    """

    parent_class: GObject.ObjectClass = ...

class TextIter(GObject.GBoxed):
    """
    :Constructors:

    ::

        TextIter()
    """

    dummy1: None = ...
    dummy2: None = ...
    dummy3: int = ...
    dummy4: int = ...
    dummy5: int = ...
    dummy6: int = ...
    dummy7: int = ...
    dummy8: int = ...
    dummy9: None = ...
    dummy10: None = ...
    dummy11: int = ...
    dummy12: int = ...
    dummy13: int = ...
    dummy14: None = ...
    def assign(self, other: TextIter) -> None: ...
    def backward_char(self) -> bool: ...
    def backward_chars(self, count: int) -> bool: ...
    def backward_cursor_position(self) -> bool: ...
    def backward_cursor_positions(self, count: int) -> bool: ...
    def backward_find_char(
        self,
        pred: typing.Callable[..., bool],
        limit: typing.Optional[TextIter] = None,
        *user_data: typing.Any,
    ) -> bool: ...
    def backward_line(self) -> bool: ...
    def backward_lines(self, count: int) -> bool: ...
    def backward_search(
        self, str: str, flags: TextSearchFlags, limit: typing.Optional[TextIter] = None
    ) -> typing.Optional[
        typing.Tuple[TextIter, TextIter]
    ]: ...  # CHECK Wrapped function
    def backward_sentence_start(self) -> bool: ...
    def backward_sentence_starts(self, count: int) -> bool: ...
    def backward_to_tag_toggle(self, tag: typing.Optional[TextTag] = None) -> bool: ...
    def backward_visible_cursor_position(self) -> bool: ...
    def backward_visible_cursor_positions(self, count: int) -> bool: ...
    def backward_visible_line(self) -> bool: ...
    def backward_visible_lines(self, count: int) -> bool: ...
    def backward_visible_word_start(self) -> bool: ...
    def backward_visible_word_starts(self, count: int) -> bool: ...
    def backward_word_start(self) -> bool: ...
    def backward_word_starts(self, count: int) -> bool: ...
    def can_insert(self, default_editability: bool) -> bool: ...
    def compare(self, rhs: TextIter) -> int: ...
    def copy(self) -> TextIter: ...
    def editable(self, default_setting: bool) -> bool: ...
    def ends_line(self) -> bool: ...
    def ends_sentence(self) -> bool: ...
    def ends_tag(self, tag: typing.Optional[TextTag] = None) -> bool: ...
    def ends_word(self) -> bool: ...
    def equal(self, rhs: TextIter) -> bool: ...
    def forward_char(self) -> bool: ...
    def forward_chars(self, count: int) -> bool: ...
    def forward_cursor_position(self) -> bool: ...
    def forward_cursor_positions(self, count: int) -> bool: ...
    def forward_find_char(
        self,
        pred: typing.Callable[..., bool],
        limit: typing.Optional[TextIter] = None,
        *user_data: typing.Any,
    ) -> bool: ...
    def forward_line(self) -> bool: ...
    def forward_lines(self, count: int) -> bool: ...
    def forward_search(
        self, str: str, flags: TextSearchFlags, limit: typing.Optional[TextIter] = None
    ) -> typing.Optional[
        typing.Tuple[TextIter, TextIter]
    ]: ...  # CHECK Wrapped function
    def forward_sentence_end(self) -> bool: ...
    def forward_sentence_ends(self, count: int) -> bool: ...
    def forward_to_end(self) -> None: ...
    def forward_to_line_end(self) -> bool: ...
    def forward_to_tag_toggle(self, tag: typing.Optional[TextTag] = None) -> bool: ...
    def forward_visible_cursor_position(self) -> bool: ...
    def forward_visible_cursor_positions(self, count: int) -> bool: ...
    def forward_visible_line(self) -> bool: ...
    def forward_visible_lines(self, count: int) -> bool: ...
    def forward_visible_word_end(self) -> bool: ...
    def forward_visible_word_ends(self, count: int) -> bool: ...
    def forward_word_end(self) -> bool: ...
    def forward_word_ends(self, count: int) -> bool: ...
    def free(self) -> None: ...
    def get_buffer(self) -> TextBuffer: ...
    def get_bytes_in_line(self) -> int: ...
    def get_char(self) -> str: ...
    def get_chars_in_line(self) -> int: ...
    def get_child_anchor(self) -> typing.Optional[TextChildAnchor]: ...
    def get_language(self) -> Pango.Language: ...
    def get_line(self) -> int: ...
    def get_line_index(self) -> int: ...
    def get_line_offset(self) -> int: ...
    def get_marks(self) -> list[TextMark]: ...
    def get_offset(self) -> int: ...
    def get_paintable(self) -> typing.Optional[Gdk.Paintable]: ...
    def get_slice(self, end: TextIter) -> str: ...
    def get_tags(self) -> list[TextTag]: ...
    def get_text(self, end: TextIter) -> str: ...
    def get_toggled_tags(self, toggled_on: bool) -> list[TextTag]: ...
    def get_visible_line_index(self) -> int: ...
    def get_visible_line_offset(self) -> int: ...
    def get_visible_slice(self, end: TextIter) -> str: ...
    def get_visible_text(self, end: TextIter) -> str: ...
    def has_tag(self, tag: TextTag) -> bool: ...
    def in_range(self, start: TextIter, end: TextIter) -> bool: ...
    def inside_sentence(self) -> bool: ...
    def inside_word(self) -> bool: ...
    def is_cursor_position(self) -> bool: ...
    def is_end(self) -> bool: ...
    def is_start(self) -> bool: ...
    def order(self, second: TextIter) -> None: ...
    def set_line(self, line_number: int) -> None: ...
    def set_line_index(self, byte_on_line: int) -> None: ...
    def set_line_offset(self, char_on_line: int) -> None: ...
    def set_offset(self, char_offset: int) -> None: ...
    def set_visible_line_index(self, byte_on_line: int) -> None: ...
    def set_visible_line_offset(self, char_on_line: int) -> None: ...
    def starts_line(self) -> bool: ...
    def starts_sentence(self) -> bool: ...
    def starts_tag(self, tag: typing.Optional[TextTag] = None) -> bool: ...
    def starts_word(self) -> bool: ...
    def toggles_tag(self, tag: typing.Optional[TextTag] = None) -> bool: ...

class TextMark(GObject.Object):
    """
    :Constructors:

    ::

        TextMark(**properties)
        new(name:str=None, left_gravity:bool) -> Gtk.TextMark

    Object GtkTextMark

    Properties from GtkTextMark:
      name -> gchararray: name
      left-gravity -> gboolean: left-gravity

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        left_gravity: bool
        name: typing.Optional[str]

    props: Props = ...
    parent_instance: GObject.Object = ...
    segment: None = ...
    def __init__(self, left_gravity: bool = ..., name: str = ...) -> None: ...
    def get_buffer(self) -> typing.Optional[TextBuffer]: ...
    def get_deleted(self) -> bool: ...
    def get_left_gravity(self) -> bool: ...
    def get_name(self) -> typing.Optional[str]: ...
    def get_visible(self) -> bool: ...
    @classmethod
    def new(cls, name: typing.Optional[str], left_gravity: bool) -> TextMark: ...
    def set_visible(self, setting: bool) -> None: ...

class TextMarkClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TextMarkClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class TextTag(GObject.Object):
    """
    :Constructors:

    ::

        TextTag(**properties)
        new(name:str=None) -> Gtk.TextTag

    Object GtkTextTag

    Properties from GtkTextTag:
      name -> gchararray: name
      background -> gchararray: background
      foreground -> gchararray: foreground
      background-rgba -> GdkRGBA: background-rgba
      foreground-rgba -> GdkRGBA: foreground-rgba
      font -> gchararray: font
      font-desc -> PangoFontDescription: font-desc
      family -> gchararray: family
      style -> PangoStyle: style
      variant -> PangoVariant: variant
      weight -> gint: weight
      stretch -> PangoStretch: stretch
      size -> gint: size
      size-points -> gdouble: size-points
      scale -> gdouble: scale
      pixels-above-lines -> gint: pixels-above-lines
      pixels-below-lines -> gint: pixels-below-lines
      pixels-inside-wrap -> gint: pixels-inside-wrap
      line-height -> gfloat: line-height
      editable -> gboolean: editable
      wrap-mode -> GtkWrapMode: wrap-mode
      justification -> GtkJustification: justification
      direction -> GtkTextDirection: direction
      left-margin -> gint: left-margin
      indent -> gint: indent
      strikethrough -> gboolean: strikethrough
      strikethrough-rgba -> GdkRGBA: strikethrough-rgba
      right-margin -> gint: right-margin
      underline -> PangoUnderline: underline
      underline-rgba -> GdkRGBA: underline-rgba
      overline -> PangoOverline: overline
      overline-rgba -> GdkRGBA: overline-rgba
      rise -> gint: rise
      background-full-height -> gboolean: background-full-height
      language -> gchararray: language
      tabs -> PangoTabArray: tabs
      invisible -> gboolean: invisible
      paragraph-background -> gchararray: paragraph-background
      paragraph-background-rgba -> GdkRGBA: paragraph-background-rgba
      fallback -> gboolean: fallback
      letter-spacing -> gint: letter-spacing
      font-features -> gchararray: font-features
      allow-breaks -> gboolean: allow-breaks
      show-spaces -> PangoShowFlags: show-spaces
      insert-hyphens -> gboolean: insert-hyphens
      text-transform -> PangoTextTransform: text-transform
      word -> gboolean: word
      sentence -> gboolean: sentence
      accumulative-margin -> gboolean: accumulative-margin
      background-set -> gboolean: background-set
      foreground-set -> gboolean: foreground-set
      family-set -> gboolean: family-set
      style-set -> gboolean: style-set
      variant-set -> gboolean: variant-set
      weight-set -> gboolean: weight-set
      stretch-set -> gboolean: stretch-set
      size-set -> gboolean: size-set
      scale-set -> gboolean: scale-set
      pixels-above-lines-set -> gboolean: pixels-above-lines-set
      pixels-below-lines-set -> gboolean: pixels-below-lines-set
      pixels-inside-wrap-set -> gboolean: pixels-inside-wrap-set
      line-height-set -> gboolean: line-height-set
      editable-set -> gboolean: editable-set
      wrap-mode-set -> gboolean: wrap-mode-set
      justification-set -> gboolean: justification-set
      left-margin-set -> gboolean: left-margin-set
      indent-set -> gboolean: indent-set
      strikethrough-set -> gboolean: strikethrough-set
      strikethrough-rgba-set -> gboolean: strikethrough-rgba-set
      right-margin-set -> gboolean: right-margin-set
      underline-set -> gboolean: underline-set
      underline-rgba-set -> gboolean: underline-rgba-set
      overline-set -> gboolean: overline-set
      overline-rgba-set -> gboolean: overline-rgba-set
      rise-set -> gboolean: rise-set
      background-full-height-set -> gboolean: background-full-height-set
      language-set -> gboolean: language-set
      tabs-set -> gboolean: tabs-set
      invisible-set -> gboolean: invisible-set
      paragraph-background-set -> gboolean: paragraph-background-set
      fallback-set -> gboolean: fallback-set
      letter-spacing-set -> gboolean: letter-spacing-set
      font-features-set -> gboolean: font-features-set
      allow-breaks-set -> gboolean: allow-breaks-set
      show-spaces-set -> gboolean: show-spaces-set
      insert-hyphens-set -> gboolean: insert-hyphens-set
      text-transform-set -> gboolean: text-transform-set
      sentence-set -> gboolean: sentence-set
      word-set -> gboolean: word-set

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        accumulative_margin: bool
        allow_breaks: bool
        allow_breaks_set: bool
        background_full_height: bool
        background_full_height_set: bool
        background_rgba: Gdk.RGBA
        background_set: bool
        direction: TextDirection
        editable: bool
        editable_set: bool
        fallback: bool
        fallback_set: bool
        family: str
        family_set: bool
        font: str
        font_desc: Pango.FontDescription
        font_features: str
        font_features_set: bool
        foreground_rgba: Gdk.RGBA
        foreground_set: bool
        indent: int
        indent_set: bool
        insert_hyphens: bool
        insert_hyphens_set: bool
        invisible: bool
        invisible_set: bool
        justification: Justification
        justification_set: bool
        language: str
        language_set: bool
        left_margin: int
        left_margin_set: bool
        letter_spacing: int
        letter_spacing_set: bool
        line_height: float
        line_height_set: bool
        name: str
        overline: Pango.Overline
        overline_rgba: Gdk.RGBA
        overline_rgba_set: bool
        overline_set: bool
        paragraph_background_rgba: Gdk.RGBA
        paragraph_background_set: bool
        pixels_above_lines: int
        pixels_above_lines_set: bool
        pixels_below_lines: int
        pixels_below_lines_set: bool
        pixels_inside_wrap: int
        pixels_inside_wrap_set: bool
        right_margin: int
        right_margin_set: bool
        rise: int
        rise_set: bool
        scale: float
        scale_set: bool
        sentence: bool
        sentence_set: bool
        show_spaces: Pango.ShowFlags
        show_spaces_set: bool
        size: int
        size_points: float
        size_set: bool
        stretch: Pango.Stretch
        stretch_set: bool
        strikethrough: bool
        strikethrough_rgba: Gdk.RGBA
        strikethrough_rgba_set: bool
        strikethrough_set: bool
        style: Pango.Style
        style_set: bool
        tabs: Pango.TabArray
        tabs_set: bool
        text_transform: Pango.TextTransform
        text_transform_set: bool
        underline: Pango.Underline
        underline_rgba: Gdk.RGBA
        underline_rgba_set: bool
        underline_set: bool
        variant: Pango.Variant
        variant_set: bool
        weight: int
        weight_set: bool
        word: bool
        word_set: bool
        wrap_mode: WrapMode
        wrap_mode_set: bool
        background: str
        foreground: str
        paragraph_background: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: TextTagPrivate = ...
    def __init__(
        self,
        accumulative_margin: bool = ...,
        allow_breaks: bool = ...,
        allow_breaks_set: bool = ...,
        background: str = ...,
        background_full_height: bool = ...,
        background_full_height_set: bool = ...,
        background_rgba: Gdk.RGBA = ...,
        background_set: bool = ...,
        direction: TextDirection = ...,
        editable: bool = ...,
        editable_set: bool = ...,
        fallback: bool = ...,
        fallback_set: bool = ...,
        family: str = ...,
        family_set: bool = ...,
        font: str = ...,
        font_desc: Pango.FontDescription = ...,
        font_features: str = ...,
        font_features_set: bool = ...,
        foreground: str = ...,
        foreground_rgba: Gdk.RGBA = ...,
        foreground_set: bool = ...,
        indent: int = ...,
        indent_set: bool = ...,
        insert_hyphens: bool = ...,
        insert_hyphens_set: bool = ...,
        invisible: bool = ...,
        invisible_set: bool = ...,
        justification: Justification = ...,
        justification_set: bool = ...,
        language: str = ...,
        language_set: bool = ...,
        left_margin: int = ...,
        left_margin_set: bool = ...,
        letter_spacing: int = ...,
        letter_spacing_set: bool = ...,
        line_height: float = ...,
        line_height_set: bool = ...,
        name: str = ...,
        overline: Pango.Overline = ...,
        overline_rgba: Gdk.RGBA = ...,
        overline_rgba_set: bool = ...,
        overline_set: bool = ...,
        paragraph_background: str = ...,
        paragraph_background_rgba: Gdk.RGBA = ...,
        paragraph_background_set: bool = ...,
        pixels_above_lines: int = ...,
        pixels_above_lines_set: bool = ...,
        pixels_below_lines: int = ...,
        pixels_below_lines_set: bool = ...,
        pixels_inside_wrap: int = ...,
        pixels_inside_wrap_set: bool = ...,
        right_margin: int = ...,
        right_margin_set: bool = ...,
        rise: int = ...,
        rise_set: bool = ...,
        scale: float = ...,
        scale_set: bool = ...,
        sentence: bool = ...,
        sentence_set: bool = ...,
        show_spaces: Pango.ShowFlags = ...,
        show_spaces_set: bool = ...,
        size: int = ...,
        size_points: float = ...,
        size_set: bool = ...,
        stretch: Pango.Stretch = ...,
        stretch_set: bool = ...,
        strikethrough: bool = ...,
        strikethrough_rgba: Gdk.RGBA = ...,
        strikethrough_rgba_set: bool = ...,
        strikethrough_set: bool = ...,
        style: Pango.Style = ...,
        style_set: bool = ...,
        tabs: Pango.TabArray = ...,
        tabs_set: bool = ...,
        text_transform: Pango.TextTransform = ...,
        text_transform_set: bool = ...,
        underline: Pango.Underline = ...,
        underline_rgba: Gdk.RGBA = ...,
        underline_rgba_set: bool = ...,
        underline_set: bool = ...,
        variant: Pango.Variant = ...,
        variant_set: bool = ...,
        weight: int = ...,
        weight_set: bool = ...,
        word: bool = ...,
        word_set: bool = ...,
        wrap_mode: WrapMode = ...,
        wrap_mode_set: bool = ...,
    ) -> None: ...
    def changed(self, size_changed: bool) -> None: ...
    def get_priority(self) -> int: ...
    @classmethod
    def new(cls, name: typing.Optional[str] = None) -> TextTag: ...
    def set_priority(self, priority: int) -> None: ...

class TextTagClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TextTagClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class TextTagPrivate(GObject.GPointer): ...

class TextTagTable(GObject.Object, Buildable):
    """
    :Constructors:

    ::

        TextTagTable(**properties)
        new() -> Gtk.TextTagTable

    Object GtkTextTagTable

    Signals from GtkTextTagTable:
      tag-changed (GtkTextTag, gboolean)
      tag-added (GtkTextTag)
      tag-removed (GtkTextTag)

    Signals from GObject:
      notify (GParam)
    """
    def add(self, tag: TextTag) -> bool: ...
    def foreach(self, func: typing.Callable[..., None], *data: typing.Any) -> None: ...
    def get_size(self) -> int: ...
    def lookup(self, name: str) -> typing.Optional[TextTag]: ...
    @classmethod
    def new(cls) -> TextTagTable: ...
    def remove(self, tag: TextTag) -> None: ...

class TextView(
    Widget, Accessible, AccessibleText, Buildable, ConstraintTarget, Scrollable
):
    """
    :Constructors:

    ::

        TextView(**properties)
        new() -> Gtk.Widget
        new_with_buffer(buffer:Gtk.TextBuffer) -> Gtk.Widget

    Object GtkTextView

    Signals from GtkTextView:
      move-cursor (GtkMovementStep, gint, gboolean)
      select-all (gboolean)
      preedit-changed (gchararray)
      copy-clipboard ()
      insert-at-cursor (gchararray)
      delete-from-cursor (GtkDeleteType, gint)
      backspace ()
      cut-clipboard ()
      paste-clipboard ()
      toggle-overwrite ()
      insert-emoji ()
      move-viewport (GtkScrollStep, gint)
      set-anchor ()
      toggle-cursor-visible ()
      extend-selection (GtkTextExtendSelection, GtkTextIter, GtkTextIter, GtkTextIter) -> gboolean

    Properties from GtkTextView:
      pixels-above-lines -> gint: pixels-above-lines
      pixels-below-lines -> gint: pixels-below-lines
      pixels-inside-wrap -> gint: pixels-inside-wrap
      editable -> gboolean: editable
      wrap-mode -> GtkWrapMode: wrap-mode
      justification -> GtkJustification: justification
      left-margin -> gint: left-margin
      right-margin -> gint: right-margin
      top-margin -> gint: top-margin
      bottom-margin -> gint: bottom-margin
      indent -> gint: indent
      tabs -> PangoTabArray: tabs
      cursor-visible -> gboolean: cursor-visible
      buffer -> GtkTextBuffer: buffer
      overwrite -> gboolean: overwrite
      accepts-tab -> gboolean: accepts-tab
      im-module -> gchararray: im-module
      input-purpose -> GtkInputPurpose: input-purpose
      input-hints -> GtkInputHints: input-hints
      monospace -> gboolean: monospace
      extra-menu -> GMenuModel: extra-menu

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        accepts_tab: bool
        bottom_margin: int
        buffer: TextBuffer
        cursor_visible: bool
        editable: bool
        extra_menu: Gio.MenuModel
        im_module: str
        indent: int
        input_hints: InputHints
        input_purpose: InputPurpose
        justification: Justification
        left_margin: int
        monospace: bool
        overwrite: bool
        pixels_above_lines: int
        pixels_below_lines: int
        pixels_inside_wrap: int
        right_margin: int
        tabs: typing.Optional[Pango.TabArray]
        top_margin: int
        wrap_mode: WrapMode
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    parent_instance: Widget = ...
    priv: TextViewPrivate = ...
    def __init__(
        self,
        accepts_tab: bool = ...,
        bottom_margin: int = ...,
        buffer: typing.Optional[TextBuffer] = ...,
        cursor_visible: bool = ...,
        editable: bool = ...,
        extra_menu: typing.Optional[Gio.MenuModel] = ...,
        im_module: str = ...,
        indent: int = ...,
        input_hints: InputHints = ...,
        input_purpose: InputPurpose = ...,
        justification: Justification = ...,
        left_margin: int = ...,
        monospace: bool = ...,
        overwrite: bool = ...,
        pixels_above_lines: int = ...,
        pixels_below_lines: int = ...,
        pixels_inside_wrap: int = ...,
        right_margin: int = ...,
        tabs: Pango.TabArray = ...,
        top_margin: int = ...,
        wrap_mode: WrapMode = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def add_child_at_anchor(self, child: Widget, anchor: TextChildAnchor) -> None: ...
    def add_overlay(self, child: Widget, xpos: int, ypos: int) -> None: ...
    def backward_display_line(self, iter: TextIter) -> bool: ...
    def backward_display_line_start(self, iter: TextIter) -> bool: ...
    def buffer_to_window_coords(
        self, win: TextWindowType, buffer_x: int, buffer_y: int
    ) -> typing.Tuple[int, int]: ...
    def do_backspace(self) -> None: ...
    def do_copy_clipboard(self) -> None: ...
    def do_cut_clipboard(self) -> None: ...
    def do_delete_from_cursor(self, type: DeleteType, count: int) -> None: ...
    def do_extend_selection(
        self,
        granularity: TextExtendSelection,
        location: TextIter,
        start: TextIter,
        end: TextIter,
    ) -> bool: ...
    def do_insert_at_cursor(self, str: str) -> None: ...
    def do_insert_emoji(self) -> None: ...
    def do_move_cursor(
        self, step: MovementStep, count: int, extend_selection: bool
    ) -> None: ...
    def do_paste_clipboard(self) -> None: ...
    def do_set_anchor(self) -> None: ...
    def do_snapshot_layer(self, layer: TextViewLayer, snapshot: Snapshot) -> None: ...
    def do_toggle_overwrite(self) -> None: ...
    def forward_display_line(self, iter: TextIter) -> bool: ...
    def forward_display_line_end(self, iter: TextIter) -> bool: ...
    def get_accepts_tab(self) -> bool: ...
    def get_bottom_margin(self) -> int: ...
    def get_buffer(self) -> TextBuffer: ...
    def get_cursor_locations(
        self, iter: typing.Optional[TextIter] = None
    ) -> typing.Tuple[Gdk.Rectangle, Gdk.Rectangle]: ...
    def get_cursor_visible(self) -> bool: ...
    def get_editable(self) -> bool: ...
    def get_extra_menu(self) -> Gio.MenuModel: ...
    def get_gutter(self, win: TextWindowType) -> typing.Optional[Widget]: ...
    def get_indent(self) -> int: ...
    def get_input_hints(self) -> InputHints: ...
    def get_input_purpose(self) -> InputPurpose: ...
    def get_iter_at_location(self, x: int, y: int) -> typing.Tuple[bool, TextIter]: ...
    def get_iter_at_position(
        self, x: int, y: int
    ) -> typing.Tuple[bool, TextIter, int]: ...
    def get_iter_location(self, iter: TextIter) -> Gdk.Rectangle: ...
    def get_justification(self) -> Justification: ...
    def get_left_margin(self) -> int: ...
    def get_line_at_y(self, y: int) -> typing.Tuple[TextIter, int]: ...
    def get_line_yrange(self, iter: TextIter) -> typing.Tuple[int, int]: ...
    def get_ltr_context(self) -> Pango.Context: ...
    def get_monospace(self) -> bool: ...
    def get_overwrite(self) -> bool: ...
    def get_pixels_above_lines(self) -> int: ...
    def get_pixels_below_lines(self) -> int: ...
    def get_pixels_inside_wrap(self) -> int: ...
    def get_right_margin(self) -> int: ...
    def get_rtl_context(self) -> Pango.Context: ...
    def get_tabs(self) -> typing.Optional[Pango.TabArray]: ...
    def get_top_margin(self) -> int: ...
    def get_visible_offset(self) -> typing.Tuple[float, float]: ...
    def get_visible_rect(self) -> Gdk.Rectangle: ...
    def get_wrap_mode(self) -> WrapMode: ...
    def im_context_filter_keypress(self, event: Gdk.Event) -> bool: ...
    def move_mark_onscreen(self, mark: TextMark) -> bool: ...
    def move_overlay(self, child: Widget, xpos: int, ypos: int) -> None: ...
    def move_visually(self, iter: TextIter, count: int) -> bool: ...
    @classmethod
    def new(cls) -> TextView: ...
    @classmethod
    def new_with_buffer(cls, buffer: TextBuffer) -> TextView: ...
    def place_cursor_onscreen(self) -> bool: ...
    def remove(self, child: Widget) -> None: ...
    def reset_cursor_blink(self) -> None: ...
    def reset_im_context(self) -> None: ...
    def scroll_mark_onscreen(self, mark: TextMark) -> None: ...
    def scroll_to_iter(
        self,
        iter: TextIter,
        within_margin: float,
        use_align: bool,
        xalign: float,
        yalign: float,
    ) -> bool: ...
    def scroll_to_mark(
        self,
        mark: TextMark,
        within_margin: float,
        use_align: bool,
        xalign: float,
        yalign: float,
    ) -> None: ...
    def set_accepts_tab(self, accepts_tab: bool) -> None: ...
    def set_bottom_margin(self, bottom_margin: int) -> None: ...
    def set_buffer(self, buffer: typing.Optional[TextBuffer] = None) -> None: ...
    def set_cursor_visible(self, setting: bool) -> None: ...
    def set_editable(self, setting: bool) -> None: ...
    def set_extra_menu(self, model: typing.Optional[Gio.MenuModel] = None) -> None: ...
    def set_gutter(
        self, win: TextWindowType, widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_indent(self, indent: int) -> None: ...
    def set_input_hints(self, hints: InputHints) -> None: ...
    def set_input_purpose(self, purpose: InputPurpose) -> None: ...
    def set_justification(self, justification: Justification) -> None: ...
    def set_left_margin(self, left_margin: int) -> None: ...
    def set_monospace(self, monospace: bool) -> None: ...
    def set_overwrite(self, overwrite: bool) -> None: ...
    def set_pixels_above_lines(self, pixels_above_lines: int) -> None: ...
    def set_pixels_below_lines(self, pixels_below_lines: int) -> None: ...
    def set_pixels_inside_wrap(self, pixels_inside_wrap: int) -> None: ...
    def set_right_margin(self, right_margin: int) -> None: ...
    def set_tabs(self, tabs: Pango.TabArray) -> None: ...
    def set_top_margin(self, top_margin: int) -> None: ...
    def set_wrap_mode(self, wrap_mode: WrapMode) -> None: ...
    def starts_display_line(self, iter: TextIter) -> bool: ...
    def window_to_buffer_coords(
        self, win: TextWindowType, window_x: int, window_y: int
    ) -> typing.Tuple[int, int]: ...

class TextViewClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TextViewClass()
    """

    parent_class: WidgetClass = ...
    move_cursor: typing.Callable[[TextView, MovementStep, int, bool], None] = ...
    set_anchor: typing.Callable[[TextView], None] = ...
    insert_at_cursor: typing.Callable[[TextView, str], None] = ...
    delete_from_cursor: typing.Callable[[TextView, DeleteType, int], None] = ...
    backspace: typing.Callable[[TextView], None] = ...
    cut_clipboard: typing.Callable[[TextView], None] = ...
    copy_clipboard: typing.Callable[[TextView], None] = ...
    paste_clipboard: typing.Callable[[TextView], None] = ...
    toggle_overwrite: typing.Callable[[TextView], None] = ...
    create_buffer: None = ...
    snapshot_layer: typing.Callable[[TextView, TextViewLayer, Snapshot], None] = ...
    extend_selection: typing.Callable[
        [TextView, TextExtendSelection, TextIter, TextIter, TextIter], bool
    ] = ...
    insert_emoji: typing.Callable[[TextView], None] = ...
    padding: list[None] = ...

class TextViewPrivate(GObject.GPointer): ...

class ToggleButton(Button, Accessible, Actionable, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        ToggleButton(**properties)
        new() -> Gtk.Widget
        new_with_label(label:str) -> Gtk.Widget
        new_with_mnemonic(label:str) -> Gtk.Widget

    Object GtkToggleButton

    Signals from GtkToggleButton:
      toggled ()

    Properties from GtkToggleButton:
      active -> gboolean: active
      group -> GtkToggleButton: group

    Signals from GtkButton:
      activate ()
      clicked ()

    Properties from GtkButton:
      label -> gchararray: label
      has-frame -> gboolean: has-frame
      use-underline -> gboolean: use-underline
      icon-name -> gchararray: icon-name
      child -> GtkWidget: child
      can-shrink -> gboolean: can-shrink

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Button.Props):
        active: bool
        can_shrink: bool
        child: typing.Optional[Widget]
        has_frame: bool
        icon_name: typing.Optional[str]
        label: typing.Optional[str]
        use_underline: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        action_name: typing.Optional[str]
        action_target: GLib.Variant
        group: typing.Optional[ToggleButton]

    props: Props = ...
    button: Button = ...
    def __init__(
        self,
        active: bool = ...,
        group: typing.Optional[ToggleButton] = ...,
        can_shrink: bool = ...,
        child: typing.Optional[Widget] = ...,
        has_frame: bool = ...,
        icon_name: str = ...,
        label: str = ...,
        use_underline: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        action_name: typing.Optional[str] = ...,
        action_target: GLib.Variant = ...,
    ) -> None: ...
    def do_toggled(self) -> None: ...
    def get_active(self) -> bool: ...
    @classmethod
    def new(cls) -> ToggleButton: ...
    @classmethod
    def new_with_label(cls, label: str) -> ToggleButton: ...
    @classmethod
    def new_with_mnemonic(cls, label: str) -> ToggleButton: ...
    def set_active(self, is_active: bool) -> None: ...
    def set_group(self, group: typing.Optional[ToggleButton] = None) -> None: ...
    def toggled(self) -> None: ...

class ToggleButtonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ToggleButtonClass()
    """

    parent_class: ButtonClass = ...
    toggled: typing.Callable[[ToggleButton], None] = ...
    padding: list[None] = ...

class Tooltip(GObject.Object):
    """
    :Constructors:

    ::

        Tooltip(**properties)

    Object GtkTooltip

    Signals from GObject:
      notify (GParam)
    """
    def set_custom(self, custom_widget: typing.Optional[Widget] = None) -> None: ...
    def set_icon(self, paintable: typing.Optional[Gdk.Paintable] = None) -> None: ...
    def set_icon_from_gicon(self, gicon: typing.Optional[Gio.Icon] = None) -> None: ...
    def set_icon_from_icon_name(
        self, icon_name: typing.Optional[str] = None
    ) -> None: ...
    def set_markup(self, markup: typing.Optional[str] = None) -> None: ...
    def set_text(self, text: typing.Optional[str] = None) -> None: ...
    def set_tip_area(self, rect: Gdk.Rectangle) -> None: ...

class TreeDragDest(GObject.GInterface):
    """
    Interface GtkTreeDragDest
    """
    def drag_data_received(self, dest: TreePath, value: typing.Any) -> bool: ...
    def row_drop_possible(self, dest_path: TreePath, value: typing.Any) -> bool: ...

class TreeDragDestIface(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeDragDestIface()
    """

    g_iface: GObject.TypeInterface = ...
    drag_data_received: typing.Callable[
        [TreeDragDest, TreePath, typing.Any], bool
    ] = ...
    row_drop_possible: typing.Callable[[TreeDragDest, TreePath, typing.Any], bool] = ...

class TreeDragSource(GObject.GInterface):
    """
    Interface GtkTreeDragSource
    """
    def drag_data_delete(self, path: TreePath) -> bool: ...
    def drag_data_get(self, path: TreePath) -> typing.Optional[Gdk.ContentProvider]: ...
    def row_draggable(self, path: TreePath) -> bool: ...

class TreeDragSourceIface(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeDragSourceIface()
    """

    g_iface: GObject.TypeInterface = ...
    row_draggable: typing.Callable[[TreeDragSource, TreePath], bool] = ...
    drag_data_get: typing.Callable[
        [TreeDragSource, TreePath], typing.Optional[Gdk.ContentProvider]
    ] = ...
    drag_data_delete: typing.Callable[[TreeDragSource, TreePath], bool] = ...

class TreeExpander(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        TreeExpander(**properties)
        new() -> Gtk.Widget

    Object GtkTreeExpander

    Properties from GtkTreeExpander:
      child -> GtkWidget: child
      hide-expander -> gboolean: hide-expander
      indent-for-depth -> gboolean: indent-for-depth
      indent-for-icon -> gboolean: indent-for-icon
      item -> GObject: item
      list-row -> GtkTreeListRow: list-row

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        hide_expander: bool
        indent_for_depth: bool
        indent_for_icon: bool
        item: typing.Optional[GObject.Object]
        list_row: typing.Optional[TreeListRow]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        hide_expander: bool = ...,
        indent_for_depth: bool = ...,
        indent_for_icon: bool = ...,
        list_row: typing.Optional[TreeListRow] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_hide_expander(self) -> bool: ...
    def get_indent_for_depth(self) -> bool: ...
    def get_indent_for_icon(self) -> bool: ...
    def get_item(self) -> typing.Optional[GObject.Object]: ...
    def get_list_row(self) -> typing.Optional[TreeListRow]: ...
    @classmethod
    def new(cls) -> TreeExpander: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_hide_expander(self, hide_expander: bool) -> None: ...
    def set_indent_for_depth(self, indent_for_depth: bool) -> None: ...
    def set_indent_for_icon(self, indent_for_icon: bool) -> None: ...
    def set_list_row(self, list_row: typing.Optional[TreeListRow] = None) -> None: ...

class TreeExpanderClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeExpanderClass()
    """

    parent_class: WidgetClass = ...

class TreeIter(GObject.GBoxed):
    """
    :Constructors:

    ::

        TreeIter()
    """

    stamp: int = ...
    user_data: None = ...
    user_data2: None = ...
    user_data3: None = ...
    def copy(self) -> TreeIter: ...
    def free(self) -> None: ...

# override
class TreeListModel(GObject.Object, Gio.ListModel[typing.Any]):
    """
    :Constructors:

    ::

        TreeListModel(**properties)
        new(root:Gio.ListModel, passthrough:bool, autoexpand:bool, create_func:Gtk.TreeListModelCreateModelFunc, user_data=None) -> Gtk.TreeListModel

    Object GtkTreeListModel

    Properties from GtkTreeListModel:
      autoexpand -> gboolean: autoexpand
      item-type -> GType: item-type
      model -> GListModel: model
      n-items -> guint: n-items
      passthrough -> gboolean: passthrough

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        autoexpand: bool
        item_type: typing.Type[typing.Any]
        model: Gio.ListModel[typing.Any]
        n_items: int
        passthrough: bool

    props: Props = ...
    def __init__(self, autoexpand: bool = ..., passthrough: bool = ...) -> None: ...
    def get_autoexpand(self) -> bool: ...
    def get_child_row(self, position: int) -> typing.Optional[TreeListRow]: ...
    def get_model(self) -> Gio.ListModel[typing.Any]: ...
    def get_passthrough(self) -> bool: ...
    def get_row(self, position: int) -> typing.Optional[TreeListRow]: ...
    @classmethod
    def new(
        cls,
        root: Gio.ListModel[typing.Any],
        passthrough: bool,
        autoexpand: bool,
        create_func: typing.Callable[..., typing.Optional[Gio.ListModel[typing.Any]]],
        *user_data: typing.Any,
    ) -> TreeListModel: ...
    def set_autoexpand(self, autoexpand: bool) -> None: ...

class TreeListModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeListModelClass()
    """

    parent_class: GObject.ObjectClass = ...

class TreeListRow(GObject.Object):
    """
    :Constructors:

    ::

        TreeListRow(**properties)

    Object GtkTreeListRow

    Properties from GtkTreeListRow:
      children -> GListModel: children
      depth -> guint: depth
      expandable -> gboolean: expandable
      expanded -> gboolean: expanded
      item -> GObject: item

    Signals from GObject:
      notify (GParam)
    """
    # override
    class Props(GObject.Object.Props):
        children: typing.Optional[Gio.ListModel[typing.Any]]
        depth: int
        expandable: bool
        expanded: bool
        item: typing.Optional[GObject.Object]

    props: Props = ...
    def __init__(self, expanded: bool = ...) -> None: ...
    def get_child_row(self, position: int) -> typing.Optional[TreeListRow]: ...
    # override
    def get_children(self) -> typing.Optional[Gio.ListModel[typing.Any]]: ...
    def get_depth(self) -> int: ...
    def get_expanded(self) -> bool: ...
    def get_item(self) -> typing.Optional[GObject.Object]: ...
    def get_parent(self) -> typing.Optional[TreeListRow]: ...
    def get_position(self) -> int: ...
    def is_expandable(self) -> bool: ...
    def set_expanded(self, expanded: bool) -> None: ...

class TreeListRowClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeListRowClass()
    """

    parent_class: GObject.ObjectClass = ...

class TreeListRowSorter(Sorter):
    """
    :Constructors:

    ::

        TreeListRowSorter(**properties)
        new(sorter:Gtk.Sorter=None) -> Gtk.TreeListRowSorter

    Object GtkTreeListRowSorter

    Properties from GtkTreeListRowSorter:
      sorter -> GtkSorter: sorter

    Signals from GtkSorter:
      changed (GtkSorterChange)

    Signals from GObject:
      notify (GParam)
    """
    class Props(Sorter.Props):
        sorter: typing.Optional[Sorter]

    props: Props = ...
    def __init__(self, sorter: typing.Optional[Sorter] = ...) -> None: ...
    def get_sorter(self) -> typing.Optional[Sorter]: ...
    @classmethod
    def new(cls, sorter: typing.Optional[Sorter] = None) -> TreeListRowSorter: ...
    def set_sorter(self, sorter: typing.Optional[Sorter] = None) -> None: ...

class TreeListRowSorterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeListRowSorterClass()
    """

    parent_class: SorterClass = ...

# override
class TreeModel(GObject.GInterface):
    """
    Interface GtkTreeModel

    Signals from GObject:
      notify (GParam)
    """

    def filter_new(self, root: typing.Optional[TreePath] = None) -> TreeModelFilter: ...
    def foreach(
        self, func: typing.Callable[..., bool], *user_data: typing.Any
    ) -> None: ...
    def get(
        self, treeiter: TreeIter, *columns: list[str]
    ) -> typing.Tuple[typing.Any, ...]: ...
    def get_column_type(self, index_: int) -> typing.Type[typing.Any]: ...
    def get_flags(self) -> TreeModelFlags: ...
    def get_iter(self, path: typing.Union[str, TreePath]) -> TreeIter: ...
    def get_iter_first(self) -> typing.Optional[TreeIter]: ...
    def get_iter_from_string(self, path_string: str) -> typing.Optional[TreeIter]: ...
    def get_n_columns(self) -> int: ...
    def get_path(self, iter: TreeIter) -> TreePath: ...
    def get_string_from_iter(self, iter: TreeIter) -> typing.Optional[str]: ...
    def get_value(self, iter: TreeIter, column: int) -> typing.Any: ...
    def iter_children(
        self, parent: typing.Optional[TreeIter] = None
    ) -> typing.Optional[TreeIter]: ...
    def iter_has_child(self, iter: TreeIter) -> bool: ...
    def iter_n_children(self, iter: typing.Optional[TreeIter] = None) -> int: ...
    def iter_next(self, aiter: TreeIter) -> typing.Optional[TreeIter]: ...
    def iter_nth_child(
        self, parent: typing.Optional[TreeIter], n: int
    ) -> typing.Optional[TreeIter]: ...
    def iter_parent(self, child: TreeIter) -> typing.Optional[TreeIter]: ...
    def iter_previous(self, aiter: TreeIter) -> typing.Optional[TreeIter]: ...
    def ref_node(self, iter: TreeIter) -> None: ...
    def row_changed(self, path: TreePath, iter: TreeIter) -> None: ...
    def row_deleted(self, path: TreePath) -> None: ...
    def row_has_child_toggled(self, path: TreePath, iter: TreeIter) -> None: ...
    def row_inserted(self, path: TreePath, iter: TreeIter) -> None: ...
    def rows_reordered(
        self, path: TreePath, iter: typing.Optional[TreeIter], new_order: list[str]
    ) -> None: ...
    def set_row(self, treeiter: TreeIter, row: list[typing.Any]) -> None: ...
    def sort_new_with_model(self) -> None: ...
    def unref_node(self, iter: TreeIter) -> None: ...
    def __getitem__(
        self, item: typing.Union[TreeIter, TreePath, str, int]
    ) -> TreeModelRow: ...
    def __delitem__(self, item: typing.Union[TreeIter, TreePath, str, int]) -> None: ...
    def __iter__(self) -> TreeModelRowIter: ...
    def __len__(self) -> int: ...

class TreeModelFilter(GObject.Object, TreeDragSource, TreeModel):
    """
    :Constructors:

    ::

        TreeModelFilter(**properties)

    Object GtkTreeModelFilter

    Properties from GtkTreeModelFilter:
      child-model -> GtkTreeModel: child-model
      virtual-root -> GtkTreePath: virtual-root

    Signals from GtkTreeModel:
      row-changed (GtkTreePath, GtkTreeIter)
      row-inserted (GtkTreePath, GtkTreeIter)
      row-has-child-toggled (GtkTreePath, GtkTreeIter)
      row-deleted (GtkTreePath)
      rows-reordered (GtkTreePath, GtkTreeIter, gpointer)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        child_model: TreeModel
        virtual_root: TreePath

    props: Props = ...
    parent: GObject.Object = ...
    priv: TreeModelFilterPrivate = ...
    def __init__(
        self, child_model: TreeModel = ..., virtual_root: TreePath = ...
    ) -> None: ...
    def clear_cache(self) -> None: ...
    def convert_child_iter_to_iter(
        self, child_iter: TreeIter
    ) -> typing.Tuple[bool, TreeIter]: ...
    def convert_child_path_to_path(
        self, child_path: TreePath
    ) -> typing.Optional[TreePath]: ...
    def convert_iter_to_child_iter(self, filter_iter: TreeIter) -> TreeIter: ...
    def convert_path_to_child_path(
        self, filter_path: TreePath
    ) -> typing.Optional[TreePath]: ...
    def do_modify(
        self, child_model: TreeModel, iter: TreeIter, value: typing.Any, column: int
    ) -> None: ...
    def do_visible(self, child_model: TreeModel, iter: TreeIter) -> bool: ...
    def get_model(self) -> TreeModel: ...
    def refilter(self) -> None: ...
    def set_modify_func(
        self,
        types: typing.Sequence[typing.Type[typing.Any]],
        func: typing.Callable[..., typing.Any],
        *data: typing.Any,
    ) -> None: ...
    def set_value(
        self, iter, column, value
    ): ...  # FIXME: Override is missing typing annotation
    def set_visible_column(self, column: int) -> None: ...
    # override
    def set_visible_func(
        self,
        func: typing.Callable[[TreeModelFilter, TreeIter, typing.Any], bool],
        data: typing.Optional[typing.Any] = ...,
    ) -> None: ...

class TreeModelFilterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeModelFilterClass()
    """

    parent_class: GObject.ObjectClass = ...
    visible: typing.Callable[[TreeModelFilter, TreeModel, TreeIter], bool] = ...
    modify: typing.Callable[
        [TreeModelFilter, TreeModel, TreeIter, typing.Any, int], None
    ] = ...
    padding: list[None] = ...

class TreeModelFilterPrivate(GObject.GPointer): ...

class TreeModelIface(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeModelIface()
    """

    g_iface: GObject.TypeInterface = ...
    row_changed: typing.Callable[[TreeModel, TreePath, TreeIter], None] = ...
    row_inserted: typing.Callable[[TreeModel, TreePath, TreeIter], None] = ...
    row_has_child_toggled: typing.Callable[[TreeModel, TreePath, TreeIter], None] = ...
    row_deleted: typing.Callable[[TreeModel, TreePath], None] = ...
    rows_reordered: typing.Callable[[TreeModel, TreePath, TreeIter, int], None] = ...
    get_flags: typing.Callable[[TreeModel], TreeModelFlags] = ...
    get_n_columns: typing.Callable[[TreeModel], int] = ...
    get_column_type: typing.Callable[[TreeModel, int], typing.Type[typing.Any]] = ...
    get_iter: typing.Callable[[TreeModel, TreePath], typing.Tuple[bool, TreeIter]] = ...
    get_path: typing.Callable[[TreeModel, TreeIter], TreePath] = ...
    get_value: typing.Callable[[TreeModel, TreeIter, int], typing.Any] = ...
    iter_next: typing.Callable[[TreeModel, TreeIter], bool] = ...
    iter_previous: typing.Callable[[TreeModel, TreeIter], bool] = ...
    iter_children: typing.Callable[
        [TreeModel, typing.Optional[TreeIter]], typing.Tuple[bool, TreeIter]
    ] = ...
    iter_has_child: typing.Callable[[TreeModel, TreeIter], bool] = ...
    iter_n_children: typing.Callable[[TreeModel, typing.Optional[TreeIter]], int] = ...
    iter_nth_child: typing.Callable[
        [TreeModel, typing.Optional[TreeIter], int], typing.Tuple[bool, TreeIter]
    ] = ...
    iter_parent: typing.Callable[
        [TreeModel, TreeIter], typing.Tuple[bool, TreeIter]
    ] = ...
    ref_node: typing.Callable[[TreeModel, TreeIter], None] = ...
    unref_node: typing.Callable[[TreeModel, TreeIter], None] = ...

# override
class TreeModelRow:
    iter: TreeIter
    model: TreeModel
    next = ...
    parent = ...
    path = ...
    previous = ...

    def get_next(self): ...
    def get_parent(self): ...
    def get_previous(self): ...
    def iterchildren(self) -> typing.Iterator[TreeModelRow]: ...
    def __getitem__(self, key: int) -> typing.Any: ...
    def __setitem__(self, key: int, value: typing.Any) -> None: ...

# override
class TreeModelRowIter:
    def next(self) -> TreeModelRow: ...
    def __next__(self) -> TreeModelRow: ...

class TreeModelSort(GObject.Object, TreeDragSource, TreeModel, TreeSortable):
    """
    :Constructors:

    ::

        TreeModelSort(**properties)
        new_with_model(child_model:Gtk.TreeModel) -> Gtk.TreeModelSort

    Object GtkTreeModelSort

    Properties from GtkTreeModelSort:
      model -> GtkTreeModel: model

    Signals from GtkTreeModel:
      row-changed (GtkTreePath, GtkTreeIter)
      row-inserted (GtkTreePath, GtkTreeIter)
      row-has-child-toggled (GtkTreePath, GtkTreeIter)
      row-deleted (GtkTreePath)
      rows-reordered (GtkTreePath, GtkTreeIter, gpointer)

    Signals from GtkTreeSortable:
      sort-column-changed ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        model: TreeModel

    props: Props = ...
    parent: GObject.Object = ...
    priv: TreeModelSortPrivate = ...
    def __init__(self, model: TreeModel = ...) -> None: ...
    def clear_cache(self) -> None: ...
    def convert_child_iter_to_iter(
        self, child_iter: TreeIter
    ) -> typing.Tuple[bool, TreeIter]: ...
    def convert_child_path_to_path(
        self, child_path: TreePath
    ) -> typing.Optional[TreePath]: ...
    def convert_iter_to_child_iter(self, sorted_iter: TreeIter) -> TreeIter: ...
    def convert_path_to_child_path(
        self, sorted_path: TreePath
    ) -> typing.Optional[TreePath]: ...
    def get_model(self) -> TreeModel: ...
    def iter_is_valid(self, iter: TreeIter) -> bool: ...
    @classmethod
    def new_with_model(cls, child_model: TreeModel) -> TreeModelSort: ...
    def reset_default_sort_func(self) -> None: ...

class TreeModelSortClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeModelSortClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class TreeModelSortPrivate(GObject.GPointer): ...

class TreePath(GObject.GBoxed):
    """
    :Constructors:

    ::

        new() -> Gtk.TreePath
        new_first() -> Gtk.TreePath
        new_from_indices(indices:list) -> Gtk.TreePath
        new_from_string(path:str) -> Gtk.TreePath or None
    """
    def __getitem__(self, index): ...  # FIXME: Override is missing typing annotation
    def __iter__(self): ...  # FIXME: Override is missing typing annotation
    def __len__(self): ...  # FIXME: Override is missing typing annotation
    def append_index(self, index_: int) -> None: ...
    def compare(self, b: TreePath) -> int: ...
    def copy(self) -> TreePath: ...
    def down(self) -> None: ...
    def free(self) -> None: ...
    def get_depth(self) -> int: ...
    def get_indices(self) -> typing.Optional[list[int]]: ...
    def is_ancestor(self, descendant: TreePath) -> bool: ...
    def is_descendant(self, ancestor: TreePath) -> bool: ...
    @classmethod
    def new(cls) -> TreePath: ...
    @classmethod
    def new_first(cls) -> TreePath: ...
    @classmethod
    def new_from_indices(cls, indices: typing.Sequence[int]) -> TreePath: ...
    @classmethod
    def new_from_string(cls, path: str) -> typing.Optional[TreePath]: ...
    def next(self) -> None: ...
    def prepend_index(self, index_: int) -> None: ...
    def prev(self) -> bool: ...
    def to_string(self) -> typing.Optional[str]: ...
    def up(self) -> bool: ...

class TreeRowData(GObject.GBoxed): ...

# override
class TreeRowReference(GObject.GBoxed):
    """
    :Constructors:

    ::

        new(model:Gtk.TreeModel, path:Gtk.TreePath) -> Gtk.TreeRowReference or None
        new_proxy(proxy:GObject.Object, model:Gtk.TreeModel, path:Gtk.TreePath) -> Gtk.TreeRowReference or None
    """

    def __init__(self, model: TreeModel, path: TreePath) -> None: ...
    def copy(self) -> TreeRowReference: ...
    @staticmethod
    def deleted(proxy: GObject.Object, path: TreePath) -> None: ...
    def free(self) -> None: ...
    def get_model(self) -> TreeModel: ...
    def get_path(self) -> typing.Optional[TreePath]: ...
    @staticmethod
    def inserted(proxy: GObject.Object, path: TreePath) -> None: ...
    @classmethod
    def new(
        cls, model: TreeModel, path: TreePath
    ) -> typing.Optional[TreeRowReference]: ...
    @classmethod
    def new_proxy(
        cls, proxy: GObject.Object, model: TreeModel, path: TreePath
    ) -> typing.Optional[TreeRowReference]: ...
    def valid(self) -> bool: ...

class TreeSelection(GObject.Object):
    """
    :Constructors:

    ::

        TreeSelection(**properties)

    Object GtkTreeSelection

    Signals from GtkTreeSelection:
      changed ()

    Properties from GtkTreeSelection:
      mode -> GtkSelectionMode: mode

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        mode: SelectionMode

    props: Props = ...
    def __init__(self, mode: SelectionMode = ...) -> None: ...
    def count_selected_rows(self) -> int: ...
    def get_mode(self) -> SelectionMode: ...
    # override
    def get_selected(self) -> typing.Tuple[TreeModel, typing.Optional[TreeIter]]: ...
    # override
    def get_selected_rows(
        self,
    ) -> typing.Optional[typing.Tuple[TreeModel, list[TreePath]]]: ...
    def get_tree_view(self) -> TreeView: ...
    def iter_is_selected(self, iter: TreeIter) -> bool: ...
    def path_is_selected(self, path: TreePath) -> bool: ...
    def select_all(self) -> None: ...
    def select_iter(self, iter: TreeIter) -> None: ...
    # override
    def select_path(self, path: TreePath) -> None: ...
    def select_range(self, start_path: TreePath, end_path: TreePath) -> None: ...
    def selected_foreach(
        self, func: typing.Callable[..., None], *data: typing.Any
    ) -> None: ...
    def set_mode(self, type: SelectionMode) -> None: ...
    def set_select_function(
        self,
        func: typing.Optional[typing.Callable[..., bool]] = None,
        *data: typing.Any,
    ) -> None: ...
    def unselect_all(self) -> None: ...
    def unselect_iter(self, iter: TreeIter) -> None: ...
    def unselect_path(self, path: TreePath) -> None: ...
    def unselect_range(self, start_path: TreePath, end_path: TreePath) -> None: ...

class TreeSortable(GObject.GInterface):
    """
    Interface GtkTreeSortable

    Signals from GObject:
      notify (GParam)
    """
    def get_sort_column_id(
        self,
    ) -> (
        typing.Tuple[int, SortType] | typing.Tuple[None, None]
    ): ...  # CHECK Wrapped function
    def has_default_sort_func(self) -> bool: ...
    def set_default_sort_func(
        self, sort_func, user_data=None
    ): ...  # FIXME: Override is missing typing annotation
    def set_sort_column_id(self, sort_column_id: int, order: SortType) -> None: ...
    # override
    def set_sort_func(
        self,
        sort_column_id: int,
        sort_func: typing.Callable[
            [TreeModel, TreeIter, TreeIter, typing.Any], typing.Any
        ],
        user_data: typing.Optional[typing.Any] = None,
    ) -> None: ...
    def sort_column_changed(self) -> None: ...

class TreeSortableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeSortableIface()
    """

    g_iface: GObject.TypeInterface = ...
    sort_column_changed: typing.Callable[[TreeSortable], None] = ...
    get_sort_column_id: typing.Callable[
        [TreeSortable], typing.Tuple[bool, int, SortType]
    ] = ...
    set_sort_column_id: typing.Callable[[TreeSortable, int, SortType], None] = ...
    set_sort_func: typing.Callable[..., None] = ...
    set_default_sort_func: typing.Callable[..., None] = ...
    has_default_sort_func: typing.Callable[[TreeSortable], bool] = ...

# override
class TreeStore(
    GObject.Object, Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
):
    """
    :Constructors:

    ::

        TreeStore(**properties)
        new(types:list) -> Gtk.TreeStore

    Object GtkTreeStore

    Signals from GtkTreeModel:
      row-changed (GtkTreePath, GtkTreeIter)
      row-inserted (GtkTreePath, GtkTreeIter)
      row-has-child-toggled (GtkTreePath, GtkTreeIter)
      row-deleted (GtkTreePath)
      rows-reordered (GtkTreePath, GtkTreeIter, gpointer)

    Signals from GtkTreeSortable:
      sort-column-changed ()

    Signals from GObject:
      notify (GParam)
    """

    parent: GObject.Object = ...
    priv: TreeStorePrivate = ...

    def __init__(self, *column_types: typing.Any) -> None: ...
    def append(
        self,
        parent: typing.Optional[TreeIter],
        row: typing.Optional[list[typing.Any]] = None,
    ) -> TreeIter: ...
    def clear(self) -> None: ...
    def insert(self, parent, position, row=None): ...
    def insert_after(self, parent, sibling, row=None): ...
    def insert_before(self, parent, sibling, row=None): ...
    def insert_with_values(
        self,
        parent: typing.Optional[TreeIter],
        position: int,
        columns: typing.Sequence[int],
        values: typing.Sequence[typing.Any],
    ) -> TreeIter: ...
    def is_ancestor(self, iter: TreeIter, descendant: TreeIter) -> bool: ...
    def iter_depth(self, iter: TreeIter) -> int: ...
    def iter_is_valid(self, iter: TreeIter) -> bool: ...
    def move_after(
        self, iter: TreeIter, position: typing.Optional[TreeIter] = None
    ) -> None: ...
    def move_before(
        self, iter: TreeIter, position: typing.Optional[TreeIter] = None
    ) -> None: ...
    @classmethod
    def new(cls, types: typing.Sequence[typing.Type[typing.Any]]) -> TreeStore: ...
    def prepend(self, parent, row=None): ...
    def remove(self, iter: TreeIter) -> bool: ...
    def set(self, treeiter, *args): ...
    def set_column_types(
        self, types: typing.Sequence[typing.Type[typing.Any]]
    ) -> None: ...
    def set_value(self, treeiter, column, value): ...
    def swap(self, a: TreeIter, b: TreeIter) -> None: ...

class TreeStoreClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeStoreClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class TreeStorePrivate(GObject.GPointer): ...

class TreeView(Widget, Accessible, Buildable, ConstraintTarget, Scrollable):
    """
    :Constructors:

    ::

        TreeView(**properties)
        new() -> Gtk.Widget
        new_with_model(model:Gtk.TreeModel) -> Gtk.Widget

    Object GtkTreeView

    Signals from GtkTreeView:
      move-cursor (GtkMovementStep, gint, gboolean, gboolean) -> gboolean
      select-all () -> gboolean
      unselect-all () -> gboolean
      row-activated (GtkTreePath, GtkTreeViewColumn)
      toggle-cursor-row () -> gboolean
      test-expand-row (GtkTreeIter, GtkTreePath) -> gboolean
      test-collapse-row (GtkTreeIter, GtkTreePath) -> gboolean
      row-expanded (GtkTreeIter, GtkTreePath)
      row-collapsed (GtkTreeIter, GtkTreePath)
      columns-changed ()
      cursor-changed ()
      select-cursor-row (gboolean) -> gboolean
      expand-collapse-cursor-row (gboolean, gboolean, gboolean) -> gboolean
      select-cursor-parent () -> gboolean
      start-interactive-search () -> gboolean

    Properties from GtkTreeView:
      model -> GtkTreeModel: model
      headers-visible -> gboolean: headers-visible
      headers-clickable -> gboolean: headers-clickable
      expander-column -> GtkTreeViewColumn: expander-column
      reorderable -> gboolean: reorderable
      enable-search -> gboolean: enable-search
      search-column -> gint: search-column
      fixed-height-mode -> gboolean: fixed-height-mode
      hover-selection -> gboolean: hover-selection
      hover-expand -> gboolean: hover-expand
      show-expanders -> gboolean: show-expanders
      level-indentation -> gint: level-indentation
      rubber-banding -> gboolean: rubber-banding
      enable-grid-lines -> GtkTreeViewGridLines: enable-grid-lines
      enable-tree-lines -> gboolean: enable-tree-lines
      tooltip-column -> gint: tooltip-column
      activate-on-single-click -> gboolean: activate-on-single-click

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        activate_on_single_click: bool
        enable_grid_lines: TreeViewGridLines
        enable_search: bool
        enable_tree_lines: bool
        expander_column: typing.Optional[TreeViewColumn]
        fixed_height_mode: bool
        headers_clickable: bool
        headers_visible: bool
        hover_expand: bool
        hover_selection: bool
        level_indentation: int
        model: typing.Optional[TreeModel]
        reorderable: bool
        rubber_banding: bool
        search_column: int
        show_expanders: bool
        tooltip_column: int
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        activate_on_single_click: bool = ...,
        enable_grid_lines: TreeViewGridLines = ...,
        enable_search: bool = ...,
        enable_tree_lines: bool = ...,
        expander_column: typing.Optional[TreeViewColumn] = ...,
        fixed_height_mode: bool = ...,
        headers_clickable: bool = ...,
        headers_visible: bool = ...,
        hover_expand: bool = ...,
        hover_selection: bool = ...,
        level_indentation: int = ...,
        model: typing.Optional[TreeModel] = ...,
        reorderable: bool = ...,
        rubber_banding: bool = ...,
        search_column: int = ...,
        show_expanders: bool = ...,
        tooltip_column: int = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def append_column(self, column: TreeViewColumn) -> int: ...
    def collapse_all(self) -> None: ...
    def collapse_row(self, path: TreePath) -> bool: ...
    def columns_autosize(self) -> None: ...
    def convert_bin_window_to_tree_coords(
        self, bx: int, by: int
    ) -> typing.Tuple[int, int]: ...
    def convert_bin_window_to_widget_coords(
        self, bx: int, by: int
    ) -> typing.Tuple[int, int]: ...
    def convert_tree_to_bin_window_coords(
        self, tx: int, ty: int
    ) -> typing.Tuple[int, int]: ...
    def convert_tree_to_widget_coords(
        self, tx: int, ty: int
    ) -> typing.Tuple[int, int]: ...
    def convert_widget_to_bin_window_coords(
        self, wx: int, wy: int
    ) -> typing.Tuple[int, int]: ...
    def convert_widget_to_tree_coords(
        self, wx: int, wy: int
    ) -> typing.Tuple[int, int]: ...
    def create_row_drag_icon(
        self, path: TreePath
    ) -> typing.Optional[Gdk.Paintable]: ...
    def do_columns_changed(self) -> None: ...
    def do_cursor_changed(self) -> None: ...
    def do_expand_collapse_cursor_row(
        self, logical: bool, expand: bool, open_all: bool
    ) -> bool: ...
    def do_move_cursor(
        self, step: MovementStep, count: int, extend: bool, modify: bool
    ) -> bool: ...
    def do_row_activated(
        self, path: TreePath, column: typing.Optional[TreeViewColumn] = None
    ) -> None: ...
    def do_row_collapsed(self, iter: TreeIter, path: TreePath) -> None: ...
    def do_row_expanded(self, iter: TreeIter, path: TreePath) -> None: ...
    def do_select_all(self) -> bool: ...
    def do_select_cursor_parent(self) -> bool: ...
    def do_select_cursor_row(self, start_editing: bool) -> bool: ...
    def do_start_interactive_search(self) -> bool: ...
    def do_test_collapse_row(self, iter: TreeIter, path: TreePath) -> bool: ...
    def do_test_expand_row(self, iter: TreeIter, path: TreePath) -> bool: ...
    def do_toggle_cursor_row(self) -> bool: ...
    def do_unselect_all(self) -> bool: ...
    def enable_model_drag_dest(
        self, formats: Gdk.ContentFormats, actions: Gdk.DragAction
    ) -> None: ...
    def enable_model_drag_source(
        self,
        start_button_mask: Gdk.ModifierType,
        formats: Gdk.ContentFormats,
        actions: Gdk.DragAction,
    ) -> None: ...
    def expand_all(self) -> None: ...
    def expand_row(self, path: TreePath, open_all: bool) -> bool: ...
    def expand_to_path(self, path: TreePath) -> None: ...
    def get_activate_on_single_click(self) -> bool: ...
    def get_background_area(
        self,
        path: typing.Optional[TreePath] = None,
        column: typing.Optional[TreeViewColumn] = None,
    ) -> Gdk.Rectangle: ...
    def get_cell_area(
        self, path, column=None
    ): ...  # FIXME: Override is missing typing annotation
    def get_column(self, n: int) -> typing.Optional[TreeViewColumn]: ...
    def get_columns(self) -> list[TreeViewColumn]: ...
    def get_cursor(self) -> typing.Tuple[TreePath, TreeViewColumn]: ...
    def get_dest_row_at_pos(
        self, drag_x: int, drag_y: int
    ) -> typing.Optional[
        typing.Tuple[TreePath, TreeViewDropPosition]
    ]: ...  # CHECK Wrapped function
    def get_drag_dest_row(self) -> typing.Tuple[TreePath, TreeViewDropPosition]: ...
    def get_enable_search(self) -> bool: ...
    def get_enable_tree_lines(self) -> bool: ...
    def get_expander_column(self) -> typing.Optional[TreeViewColumn]: ...
    def get_fixed_height_mode(self) -> bool: ...
    def get_grid_lines(self) -> TreeViewGridLines: ...
    def get_headers_clickable(self) -> bool: ...
    def get_headers_visible(self) -> bool: ...
    def get_hover_expand(self) -> bool: ...
    def get_hover_selection(self) -> bool: ...
    def get_level_indentation(self) -> int: ...
    def get_model(self) -> typing.Optional[TreeModel]: ...
    def get_n_columns(self) -> int: ...
    # override
    def get_path_at_pos(
        self, x: int, y: int
    ) -> typing.Optional[
        typing.Tuple[
            typing.Optional[TreePath], typing.Optional[TreeViewColumn], int, int
        ]
    ]: ...
    def get_reorderable(self) -> bool: ...
    def get_rubber_banding(self) -> bool: ...
    def get_search_column(self) -> int: ...
    def get_search_entry(self) -> typing.Optional[Editable]: ...
    def get_selection(self) -> TreeSelection: ...
    def get_show_expanders(self) -> bool: ...
    def get_tooltip_column(self) -> int: ...
    def get_tooltip_context(
        self, x: int, y: int, keyboard_tip: bool
    ) -> typing.Tuple[bool, TreeModel, TreePath, TreeIter]: ...
    def get_visible_range(
        self,
    ) -> typing.Optional[
        typing.Tuple[TreePath, TreePath]
    ]: ...  # CHECK Wrapped function
    def get_visible_rect(self) -> Gdk.Rectangle: ...
    def insert_column(self, column: TreeViewColumn, position: int) -> int: ...
    # override
    def insert_column_with_attributes(
        self, position: int, title: str, cell: CellRenderer, **kwargs: typing.Any
    ) -> None: ...
    def insert_column_with_data_func(
        self,
        position: int,
        title: str,
        cell: CellRenderer,
        func: typing.Callable[..., None],
        *data: typing.Any,
    ) -> int: ...
    def is_blank_at_pos(
        self, x: int, y: int
    ) -> typing.Tuple[bool, TreePath, TreeViewColumn, int, int]: ...
    def is_rubber_banding_active(self) -> bool: ...
    def map_expanded_rows(
        self, func: typing.Callable[..., None], *data: typing.Any
    ) -> None: ...
    def move_column_after(
        self,
        column: TreeViewColumn,
        base_column: typing.Optional[TreeViewColumn] = None,
    ) -> None: ...
    @classmethod
    def new(cls) -> TreeView: ...
    @classmethod
    def new_with_model(cls, model: TreeModel) -> TreeView: ...
    def remove_column(self, column: TreeViewColumn) -> int: ...
    def row_activated(
        self, path: TreePath, column: typing.Optional[TreeViewColumn] = None
    ) -> None: ...
    def row_expanded(self, path: TreePath) -> bool: ...
    # override
    def scroll_to_cell(
        self,
        path: typing.Optional[TreePath],
        column: typing.Optional[TreeViewColumn] = None,
        use_align: bool = False,
        row_align: float = 0.0,
        col_align: float = 0.0,
    ) -> None: ...
    def scroll_to_point(self, tree_x: int, tree_y: int) -> None: ...
    def set_activate_on_single_click(self, single: bool) -> None: ...
    def set_column_drag_function(
        self,
        func: typing.Optional[typing.Callable[..., bool]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    # override
    def set_cursor(
        self,
        path: TreePath,
        column: typing.Optional[TreeViewColumn] = None,
        start_editing: bool = False,
    ) -> None: ...
    def set_cursor_on_cell(
        self,
        path: TreePath,
        focus_column: typing.Optional[TreeViewColumn],
        focus_cell: typing.Optional[CellRenderer],
        start_editing: bool,
    ) -> None: ...
    def set_drag_dest_row(
        self, path: typing.Optional[TreePath], pos: TreeViewDropPosition
    ) -> None: ...
    def set_enable_search(self, enable_search: bool) -> None: ...
    def set_enable_tree_lines(self, enabled: bool) -> None: ...
    def set_expander_column(
        self, column: typing.Optional[TreeViewColumn] = None
    ) -> None: ...
    def set_fixed_height_mode(self, enable: bool) -> None: ...
    def set_grid_lines(self, grid_lines: TreeViewGridLines) -> None: ...
    def set_headers_clickable(self, setting: bool) -> None: ...
    def set_headers_visible(self, headers_visible: bool) -> None: ...
    def set_hover_expand(self, expand: bool) -> None: ...
    def set_hover_selection(self, hover: bool) -> None: ...
    def set_level_indentation(self, indentation: int) -> None: ...
    def set_model(self, model: typing.Optional[TreeModel] = None) -> None: ...
    def set_reorderable(self, reorderable: bool) -> None: ...
    def set_row_separator_func(
        self,
        func: typing.Optional[typing.Callable[..., bool]] = None,
        *data: typing.Any,
    ) -> None: ...
    def set_rubber_banding(self, enable: bool) -> None: ...
    def set_search_column(self, column: int) -> None: ...
    def set_search_entry(self, entry: typing.Optional[Editable] = None) -> None: ...
    def set_search_equal_func(
        self,
        search_equal_func: typing.Callable[..., bool],
        *search_user_data: typing.Any,
    ) -> None: ...
    def set_show_expanders(self, enabled: bool) -> None: ...
    def set_tooltip_cell(
        self,
        tooltip: Tooltip,
        path: typing.Optional[TreePath] = None,
        column: typing.Optional[TreeViewColumn] = None,
        cell: typing.Optional[CellRenderer] = None,
    ) -> None: ...
    def set_tooltip_column(self, column: int) -> None: ...
    def set_tooltip_row(self, tooltip: Tooltip, path: TreePath) -> None: ...
    def unset_rows_drag_dest(self) -> None: ...
    def unset_rows_drag_source(self) -> None: ...

class TreeViewClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TreeViewClass()
    """

    parent_class: WidgetClass = ...
    row_activated: typing.Callable[
        [TreeView, TreePath, typing.Optional[TreeViewColumn]], None
    ] = ...
    test_expand_row: typing.Callable[[TreeView, TreeIter, TreePath], bool] = ...
    test_collapse_row: typing.Callable[[TreeView, TreeIter, TreePath], bool] = ...
    row_expanded: typing.Callable[[TreeView, TreeIter, TreePath], None] = ...
    row_collapsed: typing.Callable[[TreeView, TreeIter, TreePath], None] = ...
    columns_changed: typing.Callable[[TreeView], None] = ...
    cursor_changed: typing.Callable[[TreeView], None] = ...
    move_cursor: typing.Callable[[TreeView, MovementStep, int, bool, bool], bool] = ...
    select_all: typing.Callable[[TreeView], bool] = ...
    unselect_all: typing.Callable[[TreeView], bool] = ...
    select_cursor_row: typing.Callable[[TreeView, bool], bool] = ...
    toggle_cursor_row: typing.Callable[[TreeView], bool] = ...
    expand_collapse_cursor_row: typing.Callable[
        [TreeView, bool, bool, bool], bool
    ] = ...
    select_cursor_parent: typing.Callable[[TreeView], bool] = ...
    start_interactive_search: typing.Callable[[TreeView], bool] = ...

# override
class TreeViewColumn(GObject.InitiallyUnowned, Buildable, CellLayout):
    """
    :Constructors:

    ::

        TreeViewColumn(**properties)
        new() -> Gtk.TreeViewColumn
        new_with_area(area:Gtk.CellArea) -> Gtk.TreeViewColumn

    Object GtkTreeViewColumn

    Signals from GtkTreeViewColumn:
      clicked ()

    Properties from GtkTreeViewColumn:
      visible -> gboolean: visible
      resizable -> gboolean: resizable
      x-offset -> gint: x-offset
      width -> gint: width
      spacing -> gint: spacing
      sizing -> GtkTreeViewColumnSizing: sizing
      fixed-width -> gint: fixed-width
      min-width -> gint: min-width
      max-width -> gint: max-width
      title -> gchararray: title
      expand -> gboolean: expand
      clickable -> gboolean: clickable
      widget -> GtkWidget: widget
      alignment -> gfloat: alignment
      reorderable -> gboolean: reorderable
      sort-indicator -> gboolean: sort-indicator
      sort-order -> GtkSortType: sort-order
      sort-column-id -> gint: sort-column-id
      cell-area -> GtkCellArea: cell-area

    Signals from GObject:
      notify (GParam)
    """

    class Props:
        alignment: float
        cell_area: CellArea
        clickable: bool
        expand: bool
        fixed_width: int
        max_width: int
        min_width: int
        reorderable: bool
        resizable: bool
        sizing: TreeViewColumnSizing
        sort_column_id: int
        sort_indicator: bool
        sort_order: SortType
        spacing: int
        title: str
        visible: bool
        widget: typing.Optional[Widget]
        width: int
        x_offset: int

    props: Props = ...

    def __init__(
        self,
        title: str = ...,
        cell_renderer: typing.Optional[CellRenderer] = None,
        **attributes: typing.Any,
    ) -> None: ...
    def add_attribute(
        self, cell_renderer: CellRenderer, attribute: str, column: int
    ) -> None: ...
    def cell_get_position(
        self, cell_renderer: CellRenderer
    ) -> typing.Optional[typing.Tuple[int, int]]: ...
    def cell_get_size(self) -> typing.Tuple[int, int, int, int]: ...
    def cell_is_visible(self) -> bool: ...
    def cell_set_cell_data(
        self,
        tree_model: TreeModel,
        iter: TreeIter,
        is_expander: bool,
        is_expanded: bool,
    ) -> None: ...
    def clear(self) -> None: ...
    def clear_attributes(self, cell_renderer: CellRenderer) -> None: ...
    def clicked(self) -> None: ...
    def focus_cell(self, cell: CellRenderer) -> None: ...
    def get_alignment(self) -> float: ...
    def get_button(self) -> Widget: ...
    def get_clickable(self) -> bool: ...
    def get_expand(self) -> bool: ...
    def get_fixed_width(self) -> int: ...
    def get_max_width(self) -> int: ...
    def get_min_width(self) -> int: ...
    def get_reorderable(self) -> bool: ...
    def get_resizable(self) -> bool: ...
    def get_sizing(self) -> TreeViewColumnSizing: ...
    def get_sort_column_id(self) -> int: ...
    def get_sort_indicator(self) -> bool: ...
    def get_sort_order(self) -> SortType: ...
    def get_spacing(self) -> int: ...
    def get_title(self) -> str: ...
    def get_tree_view(self) -> typing.Optional[Widget]: ...
    def get_visible(self) -> bool: ...
    def get_widget(self) -> typing.Optional[Widget]: ...
    def get_width(self) -> int: ...
    def get_x_offset(self) -> int: ...
    @classmethod
    def new(cls) -> TreeViewColumn: ...
    @classmethod
    def new_with_area(cls, area: CellArea) -> TreeViewColumn: ...
    def pack_end(self, cell: CellRenderer, expand: bool) -> None: ...
    def pack_start(self, cell: CellRenderer, expand: bool) -> None: ...
    def queue_resize(self) -> None: ...
    def set_alignment(self, xalign: float) -> None: ...
    def set_attributes(
        self, cell_renderer: CellRenderer, **attributes: typing.Any
    ) -> None: ...
    def set_cell_data_func(
        self,
        cell_renderer: CellRendererT,
        func: typing.Callable[
            [TreeViewColumn, CellRendererT, TreeModel, TreeIter, typing.Any], typing.Any
        ],
        func_data: typing.Optional[object] = None,
    ) -> None: ...
    def set_clickable(self, clickable: bool) -> None: ...
    def set_expand(self, expand: bool) -> None: ...
    def set_fixed_width(self, fixed_width: int) -> None: ...
    def set_max_width(self, max_width: int) -> None: ...
    def set_min_width(self, min_width: int) -> None: ...
    def set_reorderable(self, reorderable: bool) -> None: ...
    def set_resizable(self, resizable: bool) -> None: ...
    def set_sizing(self, type: TreeViewColumnSizing) -> None: ...
    def set_sort_column_id(self, sort_column_id: int) -> None: ...
    def set_sort_indicator(self, setting: bool) -> None: ...
    def set_sort_order(self, order: SortType) -> None: ...
    def set_spacing(self, spacing: int) -> None: ...
    def set_title(self, title: str) -> None: ...
    def set_visible(self, visible: bool) -> None: ...
    def set_widget(self, widget: typing.Optional[Widget] = None) -> None: ...

class UriLauncher(GObject.Object):
    """
    :Constructors:

    ::

        UriLauncher(**properties)
        new(uri:str=None) -> Gtk.UriLauncher

    Object GtkUriLauncher

    Properties from GtkUriLauncher:
      uri -> gchararray: uri

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        uri: typing.Optional[str]

    props: Props = ...
    def __init__(self, uri: typing.Optional[str] = ...) -> None: ...
    def can_launch(self, parent: typing.Optional[Window] = None) -> bool: ...
    def get_uri(self) -> typing.Optional[str]: ...
    def launch(
        self,
        parent: typing.Optional[Window] = None,
        cancellable: typing.Optional[Gio.Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def launch_finish(self, result: Gio.AsyncResult) -> bool: ...
    @classmethod
    def new(cls, uri: typing.Optional[str] = None) -> UriLauncher: ...
    def set_uri(self, uri: typing.Optional[str] = None) -> None: ...

class UriLauncherClass(GObject.GPointer):
    """
    :Constructors:

    ::

        UriLauncherClass()
    """

    parent_class: GObject.ObjectClass = ...

class Video(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Video(**properties)
        new() -> Gtk.Widget
        new_for_file(file:Gio.File=None) -> Gtk.Widget
        new_for_filename(filename:str=None) -> Gtk.Widget
        new_for_media_stream(stream:Gtk.MediaStream=None) -> Gtk.Widget
        new_for_resource(resource_path:str=None) -> Gtk.Widget

    Object GtkVideo

    Properties from GtkVideo:
      autoplay -> gboolean: autoplay
      file -> GFile: file
      loop -> gboolean: loop
      media-stream -> GtkMediaStream: media-stream
      graphics-offload -> GtkGraphicsOffloadEnabled: graphics-offload

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        autoplay: bool
        file: typing.Optional[Gio.File]
        graphics_offload: GraphicsOffloadEnabled
        loop: bool
        media_stream: typing.Optional[MediaStream]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        autoplay: bool = ...,
        file: typing.Optional[Gio.File] = ...,
        graphics_offload: GraphicsOffloadEnabled = ...,
        loop: bool = ...,
        media_stream: typing.Optional[MediaStream] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_autoplay(self) -> bool: ...
    def get_file(self) -> typing.Optional[Gio.File]: ...
    def get_graphics_offload(self) -> GraphicsOffloadEnabled: ...
    def get_loop(self) -> bool: ...
    def get_media_stream(self) -> typing.Optional[MediaStream]: ...
    @classmethod
    def new(cls) -> Video: ...
    @classmethod
    def new_for_file(cls, file: typing.Optional[Gio.File] = None) -> Video: ...
    @classmethod
    def new_for_filename(cls, filename: typing.Optional[str] = None) -> Video: ...
    @classmethod
    def new_for_media_stream(
        cls, stream: typing.Optional[MediaStream] = None
    ) -> Video: ...
    @classmethod
    def new_for_resource(cls, resource_path: typing.Optional[str] = None) -> Video: ...
    def set_autoplay(self, autoplay: bool) -> None: ...
    def set_file(self, file: typing.Optional[Gio.File] = None) -> None: ...
    def set_filename(self, filename: typing.Optional[str] = None) -> None: ...
    def set_graphics_offload(self, enabled: GraphicsOffloadEnabled) -> None: ...
    def set_loop(self, loop: bool) -> None: ...
    def set_media_stream(self, stream: typing.Optional[MediaStream] = None) -> None: ...
    def set_resource(self, resource_path: typing.Optional[str] = None) -> None: ...

class VideoClass(GObject.GPointer):
    """
    :Constructors:

    ::

        VideoClass()
    """

    parent_class: WidgetClass = ...

class Viewport(Widget, Accessible, Buildable, ConstraintTarget, Scrollable):
    """
    :Constructors:

    ::

        Viewport(**properties)
        new(hadjustment:Gtk.Adjustment=None, vadjustment:Gtk.Adjustment=None) -> Gtk.Widget

    Object GtkViewport

    Properties from GtkViewport:
      scroll-to-focus -> gboolean: scroll-to-focus
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        scroll_to_focus: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        hadjustment: typing.Optional[Adjustment]
        hscroll_policy: ScrollablePolicy
        vadjustment: typing.Optional[Adjustment]
        vscroll_policy: ScrollablePolicy

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        scroll_to_focus: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        hadjustment: typing.Optional[Adjustment] = ...,
        hscroll_policy: ScrollablePolicy = ...,
        vadjustment: typing.Optional[Adjustment] = ...,
        vscroll_policy: ScrollablePolicy = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_scroll_to_focus(self) -> bool: ...
    @classmethod
    def new(
        cls,
        hadjustment: typing.Optional[Adjustment] = None,
        vadjustment: typing.Optional[Adjustment] = None,
    ) -> Viewport: ...
    def scroll_to(
        self, descendant: Widget, scroll: typing.Optional[ScrollInfo] = None
    ) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_scroll_to_focus(self, scroll_to_focus: bool) -> None: ...

class VolumeButton(
    ScaleButton, Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
):
    """
    :Constructors:

    ::

        VolumeButton(**properties)
        new() -> Gtk.Widget

    Object GtkVolumeButton

    Properties from GtkVolumeButton:
      use-symbolic -> gboolean: use-symbolic

    Signals from GtkScaleButton:
      value-changed (gdouble)
      popup ()
      popdown ()

    Properties from GtkScaleButton:
      value -> gdouble: value
      adjustment -> GtkAdjustment: adjustment
      icons -> GStrv: icons
      active -> gboolean: active
      has-frame -> gboolean: has-frame

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(ScaleButton.Props):
        use_symbolic: bool
        active: bool
        adjustment: Adjustment
        has_frame: bool
        icons: list[str]
        value: float
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        orientation: Orientation

    props: Props = ...
    parent: ScaleButton = ...
    def __init__(
        self,
        use_symbolic: bool = ...,
        adjustment: Adjustment = ...,
        has_frame: bool = ...,
        icons: typing.Sequence[str] = ...,
        value: float = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
        orientation: Orientation = ...,
    ) -> None: ...
    @classmethod
    def new(cls) -> VolumeButton: ...

class Widget(GObject.InitiallyUnowned, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        Widget(**properties)

    Object GtkWidget

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.InitiallyUnowned.Props):
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    parent_instance: GObject.InitiallyUnowned = ...
    priv: WidgetPrivate = ...
    def __init__(
        self,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def __iter__(self): ...  # FIXME: Override is missing typing annotation
    def action_set_enabled(self, action_name: str, enabled: bool) -> None: ...
    def activate(self) -> bool: ...
    def activate_action(
        self, name: str, args: typing.Optional[GLib.Variant] = None
    ) -> bool: ...
    def activate_default(self) -> None: ...
    def add_controller(self, controller: EventController) -> None: ...
    def add_css_class(self, css_class: str) -> None: ...
    def add_mnemonic_label(self, label: Widget) -> None: ...
    # override
    @classmethod
    def add_shortcut(cls, shortcut: Shortcut) -> None: ...
    def add_tick_callback(
        self, callback: typing.Callable[..., bool], *user_data: typing.Any
    ) -> int: ...
    def allocate(
        self,
        width: int,
        height: int,
        baseline: int,
        transform: typing.Optional[Gsk.Transform] = None,
    ) -> None: ...
    # override
    @classmethod
    def bind_template_callback_full(
        cls, callback_name: str, callback_symbol: typing.Callable[[], None]
    ) -> None: ...
    # override
    @classmethod
    def bind_template_child_full(
        cls, name: str, internal_child: bool, struct_offset: int
    ) -> None: ...
    def child_focus(self, direction: DirectionType) -> bool: ...
    def compute_bounds(self, target: Widget) -> typing.Tuple[bool, Graphene.Rect]: ...
    def compute_expand(self, orientation: Orientation) -> bool: ...
    def compute_point(
        self, target: Widget, point: Graphene.Point
    ) -> typing.Tuple[bool, Graphene.Point]: ...
    def compute_transform(
        self, target: Widget
    ) -> typing.Tuple[bool, Graphene.Matrix]: ...
    def contains(self, x: float, y: float) -> bool: ...
    def create_pango_context(self) -> Pango.Context: ...
    def create_pango_layout(
        self, text: typing.Optional[str] = None
    ) -> Pango.Layout: ...
    def dispose_template(self, widget_type: typing.Type[typing.Any]) -> None: ...
    def do_compute_expand(self, hexpand_p: bool, vexpand_p: bool) -> None: ...
    def do_contains(self, x: float, y: float) -> bool: ...
    def do_css_changed(self, change: CssStyleChange) -> None: ...
    def do_direction_changed(self, previous_direction: TextDirection) -> None: ...
    def do_focus(self, direction: DirectionType) -> bool: ...
    def do_get_request_mode(self) -> SizeRequestMode: ...
    def do_grab_focus(self) -> bool: ...
    def do_hide(self) -> None: ...
    def do_keynav_failed(self, direction: DirectionType) -> bool: ...
    def do_map(self) -> None: ...
    def do_measure(
        self, orientation: Orientation, for_size: int
    ) -> typing.Tuple[int, int, int, int]: ...
    def do_mnemonic_activate(self, group_cycling: bool) -> bool: ...
    def do_move_focus(self, direction: DirectionType) -> None: ...
    def do_query_tooltip(
        self, x: int, y: int, keyboard_tooltip: bool, tooltip: Tooltip
    ) -> bool: ...
    def do_realize(self) -> None: ...
    def do_root(self) -> None: ...
    def do_set_focus_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def do_show(self) -> None: ...
    def do_size_allocate(self, width: int, height: int, baseline: int) -> None: ...
    def do_snapshot(self, snapshot: Snapshot) -> None: ...
    def do_state_flags_changed(self, previous_state_flags: StateFlags) -> None: ...
    def do_system_setting_changed(self, settings: SystemSetting) -> None: ...
    def do_unmap(self) -> None: ...
    def do_unrealize(self) -> None: ...
    def do_unroot(self) -> None: ...
    def drag_check_threshold(
        self, start_x: int, start_y: int, current_x: int, current_y: int
    ) -> bool: ...
    def error_bell(self) -> None: ...
    # override
    @classmethod
    def get_activate_signal(cls) -> int: ...
    def get_allocated_baseline(self) -> int: ...
    def get_allocated_height(self) -> int: ...
    def get_allocated_width(self) -> int: ...
    def get_allocation(self) -> Gdk.Rectangle: ...
    # override
    def get_ancestor(
        self, widget_type: typing.Type[WidgetT]
    ) -> typing.Optional[WidgetT]: ...
    def get_baseline(self) -> int: ...
    def get_can_focus(self) -> bool: ...
    def get_can_target(self) -> bool: ...
    def get_child_visible(self) -> bool: ...
    def get_clipboard(self) -> Gdk.Clipboard: ...
    def get_color(self) -> Gdk.RGBA: ...
    def get_css_classes(self) -> list[str]: ...
    # override
    @classmethod
    def get_css_name(cls) -> str: ...
    def get_cursor(self) -> typing.Optional[Gdk.Cursor]: ...
    # override
    @classmethod
    def get_default_direction(cls) -> TextDirection: ...
    def get_direction(self) -> TextDirection: ...
    def get_display(self) -> Gdk.Display: ...
    def get_first_child(self) -> typing.Optional[Widget]: ...
    def get_focus_child(self) -> typing.Optional[Widget]: ...
    def get_focus_on_click(self) -> bool: ...
    def get_focusable(self) -> bool: ...
    def get_font_map(self) -> typing.Optional[Pango.FontMap]: ...
    def get_font_options(self) -> typing.Optional[cairo.FontOptions]: ...
    def get_frame_clock(self) -> typing.Optional[Gdk.FrameClock]: ...
    def get_halign(self) -> Align: ...
    def get_has_tooltip(self) -> bool: ...
    def get_height(self) -> int: ...
    def get_hexpand(self) -> bool: ...
    def get_hexpand_set(self) -> bool: ...
    def get_last_child(self) -> typing.Optional[Widget]: ...
    def get_layout_manager(self) -> typing.Optional[LayoutManager]: ...
    # override
    def get_layout_manager_type(self) -> typing.Type[typing.Any]: ...
    def get_limit_events(self) -> bool: ...
    def get_mapped(self) -> bool: ...
    def get_margin_bottom(self) -> int: ...
    def get_margin_end(self) -> int: ...
    def get_margin_start(self) -> int: ...
    def get_margin_top(self) -> int: ...
    def get_name(self) -> str: ...
    def get_native(self) -> typing.Optional[Native]: ...
    def get_next_sibling(self) -> typing.Optional[Widget]: ...
    def get_opacity(self) -> float: ...
    def get_overflow(self) -> Overflow: ...
    def get_pango_context(self) -> Pango.Context: ...
    def get_parent(self) -> typing.Optional[Widget]: ...
    def get_preferred_size(self) -> typing.Tuple[Requisition, Requisition]: ...
    def get_prev_sibling(self) -> typing.Optional[Widget]: ...
    def get_primary_clipboard(self) -> Gdk.Clipboard: ...
    def get_realized(self) -> bool: ...
    def get_receives_default(self) -> bool: ...
    def get_request_mode(self) -> SizeRequestMode: ...
    def get_root(self) -> typing.Optional[Root]: ...
    def get_scale_factor(self) -> int: ...
    def get_sensitive(self) -> bool: ...
    def get_settings(self) -> Settings: ...
    def get_size(self, orientation: Orientation) -> int: ...
    def get_size_request(self) -> typing.Tuple[int, int]: ...
    def get_state_flags(self) -> StateFlags: ...
    def get_style_context(self) -> StyleContext: ...
    def get_template_child(
        self, widget_type: typing.Type[typing.Any], name: str
    ) -> GObject.Object: ...
    def get_tooltip_markup(self) -> typing.Optional[str]: ...
    def get_tooltip_text(self) -> typing.Optional[str]: ...
    def get_valign(self) -> Align: ...
    def get_vexpand(self) -> bool: ...
    def get_vexpand_set(self) -> bool: ...
    def get_visible(self) -> bool: ...
    def get_width(self) -> int: ...
    def grab_focus(self) -> bool: ...
    def has_css_class(self, css_class: str) -> bool: ...
    def has_default(self) -> bool: ...
    def has_focus(self) -> bool: ...
    def has_visible_focus(self) -> bool: ...
    def hide(self) -> None: ...
    def in_destruction(self) -> bool: ...
    def init_template(self) -> None: ...
    def insert_action_group(
        self, name: str, group: typing.Optional[Gio.ActionGroup] = None
    ) -> None: ...
    def insert_after(
        self, parent: Widget, previous_sibling: typing.Optional[Widget] = None
    ) -> None: ...
    def insert_before(
        self, parent: Widget, next_sibling: typing.Optional[Widget] = None
    ) -> None: ...
    # override
    @classmethod
    def install_action(
        cls,
        action_name: str,
        parameter_type: typing.Optional[str],
        activate: typing.Callable[[Widget, str, typing.Optional[GLib.Variant]], None],
    ) -> None: ...
    # override
    @classmethod
    def install_property_action(cls, action_name: str, property_name: str) -> None: ...
    def is_ancestor(self, ancestor: Widget) -> bool: ...
    def is_drawable(self) -> bool: ...
    def is_focus(self) -> bool: ...
    def is_sensitive(self) -> bool: ...
    def is_visible(self) -> bool: ...
    def keynav_failed(self, direction: DirectionType) -> bool: ...
    def list_mnemonic_labels(self) -> list[Widget]: ...
    def map(self) -> None: ...
    def measure(
        self, orientation: Orientation, for_size: int
    ) -> typing.Tuple[int, int, int, int]: ...
    def mnemonic_activate(self, group_cycling: bool) -> bool: ...
    # override
    def observe_children(self) -> Gio.ListModel[typing.Any]: ...
    # override
    def observe_controllers(self) -> Gio.ListModel[typing.Any]: ...
    def pick(self, x: float, y: float, flags: PickFlags) -> typing.Optional[Widget]: ...
    # override
    @classmethod
    def query_action(
        cls, index_: int
    ) -> typing.Tuple[bool, typing.Type[typing.Any], str, GLib.VariantType, str]: ...
    def queue_allocate(self) -> None: ...
    def queue_draw(self) -> None: ...
    def queue_resize(self) -> None: ...
    def realize(self) -> None: ...
    def remove_controller(self, controller: EventController) -> None: ...
    def remove_css_class(self, css_class: str) -> None: ...
    def remove_mnemonic_label(self, label: Widget) -> None: ...
    def remove_tick_callback(self, id: int) -> None: ...
    # override
    @classmethod
    def set_accessible_role(cls, accessible_role: AccessibleRole) -> None: ...
    # override
    @classmethod
    def set_activate_signal(cls, signal_id: int) -> None: ...
    # override
    @classmethod
    def set_activate_signal_from_name(cls, signal_name: str) -> None: ...
    def set_can_focus(self, can_focus: bool) -> None: ...
    def set_can_target(self, can_target: bool) -> None: ...
    def set_child_visible(self, child_visible: bool) -> None: ...
    def set_css_classes(self, classes: typing.Sequence[str]) -> None: ...
    # override
    @classmethod
    def set_css_name(cls, name: str) -> None: ...
    def set_cursor(self, cursor: typing.Optional[Gdk.Cursor] = None) -> None: ...
    def set_cursor_from_name(self, name: typing.Optional[str] = None) -> None: ...
    # override
    @classmethod
    def set_default_direction(cls, dir: TextDirection) -> None: ...
    def set_direction(self, dir: TextDirection) -> None: ...
    def set_focus_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_focus_on_click(self, focus_on_click: bool) -> None: ...
    def set_focusable(self, focusable: bool) -> None: ...
    def set_font_map(self, font_map: typing.Optional[Pango.FontMap] = None) -> None: ...
    def set_font_options(
        self, options: typing.Optional[cairo.FontOptions] = None
    ) -> None: ...
    def set_halign(self, align: Align) -> None: ...
    def set_has_tooltip(self, has_tooltip: bool) -> None: ...
    def set_hexpand(self, expand: bool) -> None: ...
    def set_hexpand_set(self, set: bool) -> None: ...
    # override
    @classmethod
    def set_layout_manager(
        cls, layout_manager: typing.Optional[LayoutManager] = None
    ) -> None: ...
    # override
    def set_layout_manager_type(self, type: typing.Type[typing.Any]) -> None: ...
    def set_limit_events(self, limit_events: bool) -> None: ...
    def set_margin_bottom(self, margin: int) -> None: ...
    def set_margin_end(self, margin: int) -> None: ...
    def set_margin_start(self, margin: int) -> None: ...
    def set_margin_top(self, margin: int) -> None: ...
    def set_name(self, name: str) -> None: ...
    def set_opacity(self, opacity: float) -> None: ...
    def set_overflow(self, overflow: Overflow) -> None: ...
    def set_parent(self, parent: Widget) -> None: ...
    def set_receives_default(self, receives_default: bool) -> None: ...
    def set_sensitive(self, sensitive: bool) -> None: ...
    def set_size_request(self, width: int, height: int) -> None: ...
    def set_state_flags(self, flags: StateFlags, clear: bool) -> None: ...
    # override
    @classmethod
    def set_template(cls, template_bytes: GLib.Bytes) -> None: ...
    # override
    @classmethod
    def set_template_from_resource(cls, resource_name: str) -> None: ...
    # override
    @classmethod
    def set_template_scope(cls, scope: BuilderScope) -> None: ...
    def set_tooltip_markup(self, markup: typing.Optional[str] = None) -> None: ...
    def set_tooltip_text(self, text: typing.Optional[str] = None) -> None: ...
    def set_valign(self, align: Align) -> None: ...
    def set_vexpand(self, expand: bool) -> None: ...
    def set_vexpand_set(self, set: bool) -> None: ...
    def set_visible(self, visible: bool) -> None: ...
    def should_layout(self) -> bool: ...
    def show(self) -> None: ...
    def size_allocate(self, allocation: Gdk.Rectangle, baseline: int) -> None: ...
    def snapshot_child(self, child: Widget, snapshot: Snapshot) -> None: ...
    def translate_coordinates(
        self, dest_widget: Widget, src_x: float, src_y: float
    ) -> typing.Optional[typing.Tuple[float, float]]: ...  # CHECK Wrapped function
    def trigger_tooltip_query(self) -> None: ...
    def unmap(self) -> None: ...
    def unparent(self) -> None: ...
    def unrealize(self) -> None: ...
    def unset_state_flags(self, flags: StateFlags) -> None: ...

class WidgetClass(GObject.GPointer):
    """
    :Constructors:

    ::

        WidgetClass()
    """

    parent_class: GObject.InitiallyUnownedClass = ...
    show: typing.Callable[[Widget], None] = ...
    hide: typing.Callable[[Widget], None] = ...
    map: typing.Callable[[Widget], None] = ...
    unmap: typing.Callable[[Widget], None] = ...
    realize: typing.Callable[[Widget], None] = ...
    unrealize: typing.Callable[[Widget], None] = ...
    root: typing.Callable[[Widget], None] = ...
    unroot: typing.Callable[[Widget], None] = ...
    size_allocate: typing.Callable[[Widget, int, int, int], None] = ...
    state_flags_changed: typing.Callable[[Widget, StateFlags], None] = ...
    direction_changed: typing.Callable[[Widget, TextDirection], None] = ...
    get_request_mode: typing.Callable[[Widget], SizeRequestMode] = ...
    measure: typing.Callable[
        [Widget, Orientation, int], typing.Tuple[int, int, int, int]
    ] = ...
    mnemonic_activate: typing.Callable[[Widget, bool], bool] = ...
    grab_focus: typing.Callable[[Widget], bool] = ...
    focus: typing.Callable[[Widget, DirectionType], bool] = ...
    set_focus_child: typing.Callable[[Widget, typing.Optional[Widget]], None] = ...
    move_focus: typing.Callable[[Widget, DirectionType], None] = ...
    keynav_failed: typing.Callable[[Widget, DirectionType], bool] = ...
    query_tooltip: typing.Callable[[Widget, int, int, bool, Tooltip], bool] = ...
    compute_expand: typing.Callable[[Widget, bool, bool], None] = ...
    css_changed: typing.Callable[[Widget, CssStyleChange], None] = ...
    system_setting_changed: typing.Callable[[Widget, SystemSetting], None] = ...
    snapshot: typing.Callable[[Widget, Snapshot], None] = ...
    contains: typing.Callable[[Widget, float, float], bool] = ...
    priv: WidgetClassPrivate = ...
    padding: list[None] = ...
    def add_shortcut(self, shortcut: Shortcut) -> None: ...
    def bind_template_callback_full(
        self, callback_name: str, callback_symbol: typing.Callable[[], None]
    ) -> None: ...
    def bind_template_child_full(
        self, name: str, internal_child: bool, struct_offset: int
    ) -> None: ...
    # override
    @classmethod
    def get_accessible_role(cls) -> AccessibleRole: ...
    def get_activate_signal(self) -> int: ...
    def get_css_name(self) -> str: ...
    # override
    @classmethod
    def get_layout_manager_type(cls) -> typing.Type[typing.Any]: ...
    def install_action(
        self,
        action_name: str,
        parameter_type: typing.Optional[str],
        activate: typing.Callable[[Widget, str, typing.Optional[GLib.Variant]], None],
    ) -> None: ...
    def install_property_action(self, action_name: str, property_name: str) -> None: ...
    def query_action(
        self, index_: int
    ) -> typing.Tuple[bool, typing.Type[typing.Any], str, GLib.VariantType, str]: ...
    def set_accessible_role(self, accessible_role: AccessibleRole) -> None: ...
    def set_activate_signal(self, signal_id: int) -> None: ...
    def set_activate_signal_from_name(self, signal_name: str) -> None: ...
    def set_css_name(self, name: str) -> None: ...
    def set_layout_manager_type(self, type: typing.Type[typing.Any]) -> None: ...
    def set_template(self, template_bytes: GLib.Bytes) -> None: ...
    def set_template_from_resource(self, resource_name: str) -> None: ...
    def set_template_scope(self, scope: BuilderScope) -> None: ...

class WidgetClassPrivate(GObject.GPointer): ...

class WidgetPaintable(GObject.Object, Gdk.Paintable):
    """
    :Constructors:

    ::

        WidgetPaintable(**properties)
        new(widget:Gtk.Widget=None) -> Gtk.WidgetPaintable

    Object GtkWidgetPaintable

    Properties from GtkWidgetPaintable:
      widget -> GtkWidget: widget

    Signals from GdkPaintable:
      invalidate-contents ()
      invalidate-size ()

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        widget: typing.Optional[Widget]

    props: Props = ...
    def __init__(self, widget: typing.Optional[Widget] = ...) -> None: ...
    def get_widget(self) -> typing.Optional[Widget]: ...
    @classmethod
    def new(cls, widget: typing.Optional[Widget] = None) -> WidgetPaintable: ...
    def set_widget(self, widget: typing.Optional[Widget] = None) -> None: ...

class WidgetPaintableClass(GObject.GPointer):
    """
    :Constructors:

    ::

        WidgetPaintableClass()
    """

    parent_class: GObject.ObjectClass = ...

class WidgetPrivate(GObject.GPointer): ...

class Window(
    Widget, Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
):
    """
    :Constructors:

    ::

        Window(**properties)
        new() -> Gtk.Widget

    Object GtkWindow

    Signals from GtkWindow:
      keys-changed ()
      activate-focus ()
      activate-default ()
      enable-debugging (gboolean) -> gboolean
      close-request () -> gboolean

    Properties from GtkWindow:
      title -> gchararray: title
      resizable -> gboolean: resizable
      modal -> gboolean: modal
      default-width -> gint: default-width
      default-height -> gint: default-height
      destroy-with-parent -> gboolean: destroy-with-parent
      hide-on-close -> gboolean: hide-on-close
      icon-name -> gchararray: icon-name
      display -> GdkDisplay: display
      decorated -> gboolean: decorated
      deletable -> gboolean: deletable
      transient-for -> GtkWindow: transient-for
      application -> GtkApplication: application
      default-widget -> GtkWidget: default-widget
      focus-widget -> GtkWidget: focus-widget
      child -> GtkWidget: child
      titlebar -> GtkWidget: titlebar
      handle-menubar-accel -> gboolean: handle-menubar-accel
      gravity -> GtkWindowGravity: gravity
      is-active -> gboolean: is-active
      suspended -> gboolean: suspended
      startup-id -> gchararray: startup-id
      mnemonics-visible -> gboolean: mnemonics-visible
      focus-visible -> gboolean: focus-visible
      maximized -> gboolean: maximized
      fullscreened -> gboolean: fullscreened

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        application: typing.Optional[Application]
        child: typing.Optional[Widget]
        decorated: bool
        default_height: int
        default_widget: typing.Optional[Widget]
        default_width: int
        deletable: bool
        destroy_with_parent: bool
        display: Gdk.Display
        focus_visible: bool
        focus_widget: typing.Optional[Widget]
        fullscreened: bool
        gravity: WindowGravity
        handle_menubar_accel: bool
        hide_on_close: bool
        icon_name: typing.Optional[str]
        is_active: bool
        maximized: bool
        mnemonics_visible: bool
        modal: bool
        resizable: bool
        suspended: bool
        title: typing.Optional[str]
        titlebar: typing.Optional[Widget]
        transient_for: typing.Optional[Window]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole
        startup_id: str

    props: Props = ...
    parent_instance: Widget = ...
    def __init__(
        self,
        application: typing.Optional[Application] = ...,
        child: typing.Optional[Widget] = ...,
        decorated: bool = ...,
        default_height: int = ...,
        default_widget: typing.Optional[Widget] = ...,
        default_width: int = ...,
        deletable: bool = ...,
        destroy_with_parent: bool = ...,
        display: Gdk.Display = ...,
        focus_visible: bool = ...,
        focus_widget: typing.Optional[Widget] = ...,
        fullscreened: bool = ...,
        gravity: WindowGravity = ...,
        handle_menubar_accel: bool = ...,
        hide_on_close: bool = ...,
        icon_name: typing.Optional[str] = ...,
        maximized: bool = ...,
        mnemonics_visible: bool = ...,
        modal: bool = ...,
        resizable: bool = ...,
        startup_id: str = ...,
        title: typing.Optional[str] = ...,
        titlebar: typing.Optional[Widget] = ...,
        transient_for: typing.Optional[Window] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def close(self) -> None: ...
    def destroy(self) -> None: ...
    def do_activate_default(self) -> None: ...
    def do_activate_focus(self) -> None: ...
    def do_close_request(self) -> bool: ...
    def do_enable_debugging(self, toggle: bool) -> bool: ...
    def do_keys_changed(self) -> None: ...
    def fullscreen(self) -> None: ...
    def fullscreen_on_monitor(self, monitor: Gdk.Monitor) -> None: ...
    def get_application(self) -> typing.Optional[Application]: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    def get_decorated(self) -> bool: ...
    @staticmethod
    def get_default_icon_name() -> typing.Optional[str]: ...
    def get_default_size(self) -> typing.Tuple[int, int]: ...
    def get_default_widget(self) -> typing.Optional[Widget]: ...
    def get_deletable(self) -> bool: ...
    def get_destroy_with_parent(self) -> bool: ...
    def get_focus(self) -> typing.Optional[Widget]: ...
    def get_focus_visible(self) -> bool: ...
    def get_gravity(self) -> WindowGravity: ...
    def get_group(self) -> WindowGroup: ...
    def get_handle_menubar_accel(self) -> bool: ...
    def get_hide_on_close(self) -> bool: ...
    def get_icon_name(self) -> typing.Optional[str]: ...
    def get_mnemonics_visible(self) -> bool: ...
    def get_modal(self) -> bool: ...
    def get_resizable(self) -> bool: ...
    def get_title(self) -> typing.Optional[str]: ...
    def get_titlebar(self) -> typing.Optional[Widget]: ...
    # override
    @staticmethod
    def get_toplevels() -> Gio.ListModel[typing.Any]: ...
    def get_transient_for(self) -> typing.Optional[Window]: ...
    def has_group(self) -> bool: ...
    def is_active(self) -> bool: ...
    def is_fullscreen(self) -> bool: ...
    def is_maximized(self) -> bool: ...
    def is_suspended(self) -> bool: ...
    @staticmethod
    def list_toplevels() -> list[Widget]: ...
    def maximize(self) -> None: ...
    def minimize(self) -> None: ...
    @classmethod
    def new(cls) -> Window: ...
    def present(self) -> None: ...
    def present_with_time(self, timestamp: int) -> None: ...
    def set_application(
        self, application: typing.Optional[Application] = None
    ) -> None: ...
    @staticmethod
    def set_auto_startup_notification(setting: bool) -> None: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...
    def set_decorated(self, setting: bool) -> None: ...
    @staticmethod
    def set_default_icon_name(name: str) -> None: ...
    def set_default_size(self, width: int, height: int) -> None: ...
    def set_default_widget(
        self, default_widget: typing.Optional[Widget] = None
    ) -> None: ...
    def set_deletable(self, setting: bool) -> None: ...
    def set_destroy_with_parent(self, setting: bool) -> None: ...
    def set_display(self, display: Gdk.Display) -> None: ...
    def set_focus(self, focus: typing.Optional[Widget] = None) -> None: ...
    def set_focus_visible(self, setting: bool) -> None: ...
    def set_gravity(self, gravity: WindowGravity) -> None: ...
    def set_handle_menubar_accel(self, handle_menubar_accel: bool) -> None: ...
    def set_hide_on_close(self, setting: bool) -> None: ...
    def set_icon_name(self, name: typing.Optional[str] = None) -> None: ...
    @staticmethod
    def set_interactive_debugging(enable: bool) -> None: ...
    def set_mnemonics_visible(self, setting: bool) -> None: ...
    def set_modal(self, modal: bool) -> None: ...
    def set_resizable(self, resizable: bool) -> None: ...
    def set_startup_id(self, startup_id: str) -> None: ...
    def set_title(self, title: typing.Optional[str] = None) -> None: ...
    def set_titlebar(self, titlebar: typing.Optional[Widget] = None) -> None: ...
    def set_transient_for(self, parent: typing.Optional[Window] = None) -> None: ...
    def unfullscreen(self) -> None: ...
    def unmaximize(self) -> None: ...
    def unminimize(self) -> None: ...

class WindowClass(GObject.GPointer):
    """
    :Constructors:

    ::

        WindowClass()
    """

    parent_class: WidgetClass = ...
    activate_focus: typing.Callable[[Window], None] = ...
    activate_default: typing.Callable[[Window], None] = ...
    keys_changed: typing.Callable[[Window], None] = ...
    enable_debugging: typing.Callable[[Window, bool], bool] = ...
    close_request: typing.Callable[[Window], bool] = ...
    padding: list[None] = ...

class WindowControls(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        WindowControls(**properties)
        new(side:Gtk.PackType) -> Gtk.Widget

    Object GtkWindowControls

    Properties from GtkWindowControls:
      side -> GtkPackType: side
      decoration-layout -> gchararray: decoration-layout
      use-native-controls -> gboolean: use-native-controls
      empty -> gboolean: empty

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        decoration_layout: typing.Optional[str]
        empty: bool
        side: PackType
        use_native_controls: bool
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        decoration_layout: typing.Optional[str] = ...,
        side: PackType = ...,
        use_native_controls: bool = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_decoration_layout(self) -> typing.Optional[str]: ...
    def get_empty(self) -> bool: ...
    def get_side(self) -> PackType: ...
    def get_use_native_controls(self) -> bool: ...
    @classmethod
    def new(cls, side: PackType) -> WindowControls: ...
    def set_decoration_layout(self, layout: typing.Optional[str] = None) -> None: ...
    def set_side(self, side: PackType) -> None: ...
    def set_use_native_controls(self, setting: bool) -> None: ...

class WindowControlsClass(GObject.GPointer):
    """
    :Constructors:

    ::

        WindowControlsClass()
    """

    parent_class: WidgetClass = ...

class WindowGroup(GObject.Object):
    """
    :Constructors:

    ::

        WindowGroup(**properties)
        new() -> Gtk.WindowGroup

    Object GtkWindowGroup

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: WindowGroupPrivate = ...
    def add_window(self, window: Window) -> None: ...
    def list_windows(self) -> list[Window]: ...
    @classmethod
    def new(cls) -> WindowGroup: ...
    def remove_window(self, window: Window) -> None: ...

class WindowGroupClass(GObject.GPointer):
    """
    :Constructors:

    ::

        WindowGroupClass()
    """

    parent_class: GObject.ObjectClass = ...

class WindowGroupPrivate(GObject.GPointer): ...

class WindowHandle(Widget, Accessible, Buildable, ConstraintTarget):
    """
    :Constructors:

    ::

        WindowHandle(**properties)
        new() -> Gtk.Widget

    Object GtkWindowHandle

    Properties from GtkWindowHandle:
      child -> GtkWidget: child

    Signals from GtkWidget:
      direction-changed (GtkTextDirection)
      destroy ()
      show ()
      hide ()
      map ()
      unmap ()
      realize ()
      unrealize ()
      state-flags-changed (GtkStateFlags)
      mnemonic-activate (gboolean) -> gboolean
      move-focus (GtkDirectionType)
      keynav-failed (GtkDirectionType) -> gboolean
      query-tooltip (gint, gint, gboolean, GtkTooltip) -> gboolean

    Properties from GtkWidget:
      name -> gchararray: name
      parent -> GtkWidget: parent
      root -> GtkRoot: root
      width-request -> gint: width-request
      height-request -> gint: height-request
      visible -> gboolean: visible
      sensitive -> gboolean: sensitive
      can-focus -> gboolean: can-focus
      has-focus -> gboolean: has-focus
      can-target -> gboolean: can-target
      focus-on-click -> gboolean: focus-on-click
      focusable -> gboolean: focusable
      has-default -> gboolean: has-default
      receives-default -> gboolean: receives-default
      cursor -> GdkCursor: cursor
      has-tooltip -> gboolean: has-tooltip
      tooltip-markup -> gchararray: tooltip-markup
      tooltip-text -> gchararray: tooltip-text
      opacity -> gdouble: opacity
      overflow -> GtkOverflow: overflow
      halign -> GtkAlign: halign
      valign -> GtkAlign: valign
      margin-start -> gint: margin-start
      margin-end -> gint: margin-end
      margin-top -> gint: margin-top
      margin-bottom -> gint: margin-bottom
      hexpand -> gboolean: hexpand
      vexpand -> gboolean: vexpand
      hexpand-set -> gboolean: hexpand-set
      vexpand-set -> gboolean: vexpand-set
      scale-factor -> gint: scale-factor
      css-name -> gchararray: css-name
      css-classes -> GStrv: css-classes
      layout-manager -> GtkLayoutManager: layout-manager
      limit-events -> gboolean: limit-events

    Signals from GObject:
      notify (GParam)
    """
    class Props(Widget.Props):
        child: typing.Optional[Widget]
        can_focus: bool
        can_target: bool
        css_classes: list[str]
        css_name: str
        cursor: typing.Optional[Gdk.Cursor]
        focus_on_click: bool
        focusable: bool
        halign: Align
        has_default: bool
        has_focus: bool
        has_tooltip: bool
        height_request: int
        hexpand: bool
        hexpand_set: bool
        layout_manager: typing.Optional[LayoutManager]
        limit_events: bool
        margin_bottom: int
        margin_end: int
        margin_start: int
        margin_top: int
        name: str
        opacity: float
        overflow: Overflow
        parent: typing.Optional[Widget]
        receives_default: bool
        root: typing.Optional[Root]
        scale_factor: int
        sensitive: bool
        tooltip_markup: typing.Optional[str]
        tooltip_text: typing.Optional[str]
        valign: Align
        vexpand: bool
        vexpand_set: bool
        visible: bool
        width_request: int
        accessible_role: AccessibleRole

    props: Props = ...
    def __init__(
        self,
        child: typing.Optional[Widget] = ...,
        can_focus: bool = ...,
        can_target: bool = ...,
        css_classes: typing.Sequence[str] = ...,
        css_name: str = ...,
        cursor: typing.Optional[Gdk.Cursor] = ...,
        focus_on_click: bool = ...,
        focusable: bool = ...,
        halign: Align = ...,
        has_tooltip: bool = ...,
        height_request: int = ...,
        hexpand: bool = ...,
        hexpand_set: bool = ...,
        layout_manager: typing.Optional[LayoutManager] = ...,
        limit_events: bool = ...,
        margin_bottom: int = ...,
        margin_end: int = ...,
        margin_start: int = ...,
        margin_top: int = ...,
        name: str = ...,
        opacity: float = ...,
        overflow: Overflow = ...,
        receives_default: bool = ...,
        sensitive: bool = ...,
        tooltip_markup: typing.Optional[str] = ...,
        tooltip_text: typing.Optional[str] = ...,
        valign: Align = ...,
        vexpand: bool = ...,
        vexpand_set: bool = ...,
        visible: bool = ...,
        width_request: int = ...,
        accessible_role: AccessibleRole = ...,
    ) -> None: ...
    def get_child(self) -> typing.Optional[Widget]: ...
    @classmethod
    def new(cls) -> WindowHandle: ...
    def set_child(self, child: typing.Optional[Widget] = None) -> None: ...

class WindowHandleClass(GObject.GPointer):
    """
    :Constructors:

    ::

        WindowHandleClass()
    """

    parent_class: WidgetClass = ...

class ApplicationInhibitFlags(GObject.GFlags):
    IDLE = 8
    LOGOUT = 1
    SUSPEND = 4
    SWITCH = 2

class BuilderClosureFlags(GObject.GFlags):
    SWAPPED = 1

class CellRendererState(GObject.GFlags):
    EXPANDABLE = 32
    EXPANDED = 64
    FOCUSED = 16
    INSENSITIVE = 4
    PRELIT = 2
    SELECTED = 1
    SORTED = 8

class DebugFlags(GObject.GFlags):
    A11Y = 131072
    ACTIONS = 4096
    BUILDER = 2097152
    BUILDER_OBJECTS = 65536
    BUILDER_TRACE = 128
    CONSTRAINTS = 32768
    CSS = 1048576
    GEOMETRY = 16
    ICONFALLBACK = 262144
    ICONTHEME = 32
    INTERACTIVE = 1024
    INVERT_TEXT_DIR = 524288
    KEYBINDINGS = 4
    LAYOUT = 8192
    MODULES = 8
    NO_CSS_CACHE = 512
    PRINTING = 64
    SIZE_REQUEST = 256
    SNAPSHOT = 16384
    TEXT = 1
    TOUCHSCREEN = 2048
    TREE = 2

class DialogFlags(GObject.GFlags):
    DESTROY_WITH_PARENT = 2
    MODAL = 1
    USE_HEADER_BAR = 4

class EventControllerScrollFlags(GObject.GFlags):
    BOTH_AXES = 3
    DISCRETE = 4
    HORIZONTAL = 2
    KINETIC = 8
    NONE = 0
    PHYSICAL_DIRECTION = 16
    VERTICAL = 1

class FontChooserLevel(GObject.GFlags):
    FAMILY = 0
    FEATURES = 8
    SIZE = 2
    STYLE = 1
    VARIATIONS = 4

class IconLookupFlags(GObject.GFlags):
    FORCE_REGULAR = 1
    FORCE_SYMBOLIC = 2
    NONE = 0
    PRELOAD = 4

class InputHints(GObject.GFlags):
    EMOJI = 512
    INHIBIT_OSK = 128
    LOWERCASE = 8
    NONE = 0
    NO_EMOJI = 1024
    NO_SPELLCHECK = 2
    PRIVATE = 2048
    SPELLCHECK = 1
    UPPERCASE_CHARS = 16
    UPPERCASE_SENTENCES = 64
    UPPERCASE_WORDS = 32
    VERTICAL_WRITING = 256
    WORD_COMPLETION = 4

class ListScrollFlags(GObject.GFlags):
    FOCUS = 1
    NONE = 0
    SELECT = 2

class PickFlags(GObject.GFlags):
    DEFAULT = 0
    INSENSITIVE = 1
    NON_TARGETABLE = 2

class PopoverMenuFlags(GObject.GFlags):
    NESTED = 1
    SLIDING = 0

class PrintCapabilities(GObject.GFlags):
    COLLATE = 4
    COPIES = 2
    GENERATE_PDF = 32
    GENERATE_PS = 64
    NUMBER_UP = 256
    NUMBER_UP_LAYOUT = 512
    PAGE_SET = 1
    PREVIEW = 128
    REVERSE = 8
    SCALE = 16

class ShortcutActionFlags(GObject.GFlags):
    EXCLUSIVE = 1

class StateFlags(GObject.GFlags):
    ACTIVE = 1
    BACKDROP = 64
    CHECKED = 2048
    DIR_LTR = 128
    DIR_RTL = 256
    DROP_ACTIVE = 4096
    FOCUSED = 32
    FOCUS_VISIBLE = 8192
    FOCUS_WITHIN = 16384
    INCONSISTENT = 16
    INSENSITIVE = 8
    LINK = 512
    NORMAL = 0
    PRELIGHT = 2
    SELECTED = 4
    VISITED = 1024

class StyleContextPrintFlags(GObject.GFlags):
    NONE = 0
    RECURSE = 1
    SHOW_CHANGE = 4
    SHOW_STYLE = 2

class TextBufferNotifyFlags(GObject.GFlags):
    AFTER_DELETE = 8
    AFTER_INSERT = 2
    BEFORE_DELETE = 4
    BEFORE_INSERT = 1

class TextSearchFlags(GObject.GFlags):
    CASE_INSENSITIVE = 4
    TEXT_ONLY = 2
    VISIBLE_ONLY = 1

class TreeModelFlags(GObject.GFlags):
    ITERS_PERSIST = 1
    LIST_ONLY = 2

class AccessibleAnnouncementPriority(GObject.GEnum):
    HIGH = 2
    LOW = 0
    MEDIUM = 1

class AccessibleAutocomplete(GObject.GEnum):
    BOTH = 3
    INLINE = 1
    LIST = 2
    NONE = 0

class AccessibleInvalidState(GObject.GEnum):
    FALSE = 0
    GRAMMAR = 2
    SPELLING = 3
    TRUE = 1

class AccessiblePlatformState(GObject.GEnum):
    ACTIVE = 2
    FOCUSABLE = 0
    FOCUSED = 1

class AccessibleProperty(GObject.GEnum):
    AUTOCOMPLETE = 0
    DESCRIPTION = 1
    HAS_POPUP = 2
    HELP_TEXT = 19
    KEY_SHORTCUTS = 3
    LABEL = 4
    LEVEL = 5
    MODAL = 6
    MULTI_LINE = 7
    MULTI_SELECTABLE = 8
    ORIENTATION = 9
    PLACEHOLDER = 10
    READ_ONLY = 11
    REQUIRED = 12
    ROLE_DESCRIPTION = 13
    SORT = 14
    VALUE_MAX = 15
    VALUE_MIN = 16
    VALUE_NOW = 17
    VALUE_TEXT = 18
    @staticmethod
    def init_value(property: AccessibleProperty, value: typing.Any) -> None: ...

class AccessibleRelation(GObject.GEnum):
    ACTIVE_DESCENDANT = 0
    COL_COUNT = 1
    COL_INDEX = 2
    COL_INDEX_TEXT = 3
    COL_SPAN = 4
    CONTROLLED_BY = 20
    CONTROLS = 5
    DESCRIBED_BY = 6
    DESCRIPTION_FOR = 19
    DETAILS = 7
    DETAILS_FOR = 21
    ERROR_MESSAGE = 8
    ERROR_MESSAGE_FOR = 22
    FLOW_FROM = 23
    FLOW_TO = 9
    LABELLED_BY = 10
    LABEL_FOR = 18
    OWNS = 11
    POS_IN_SET = 12
    ROW_COUNT = 13
    ROW_INDEX = 14
    ROW_INDEX_TEXT = 15
    ROW_SPAN = 16
    SET_SIZE = 17
    @staticmethod
    def init_value(relation: AccessibleRelation, value: typing.Any) -> None: ...

class AccessibleRole(GObject.GEnum):
    ALERT = 0
    ALERT_DIALOG = 1
    APPLICATION = 79
    ARTICLE = 82
    BANNER = 2
    BLOCK_QUOTE = 81
    BUTTON = 3
    CAPTION = 4
    CELL = 5
    CHECKBOX = 6
    COLUMN_HEADER = 7
    COMBO_BOX = 8
    COMMAND = 9
    COMMENT = 83
    COMPOSITE = 10
    DIALOG = 11
    DOCUMENT = 12
    FEED = 13
    FORM = 14
    GENERIC = 15
    GRID = 16
    GRID_CELL = 17
    GROUP = 18
    HEADING = 19
    IMG = 20
    INPUT = 21
    LABEL = 22
    LANDMARK = 23
    LEGEND = 24
    LINK = 25
    LIST = 26
    LIST_BOX = 27
    LIST_ITEM = 28
    LOG = 29
    MAIN = 30
    MARQUEE = 31
    MATH = 32
    MENU = 34
    MENU_BAR = 35
    MENU_ITEM = 36
    MENU_ITEM_CHECKBOX = 37
    MENU_ITEM_RADIO = 38
    METER = 33
    NAVIGATION = 39
    NONE = 40
    NOTE = 41
    OPTION = 42
    PARAGRAPH = 80
    PRESENTATION = 43
    PROGRESS_BAR = 44
    RADIO = 45
    RADIO_GROUP = 46
    RANGE = 47
    REGION = 48
    ROW = 49
    ROW_GROUP = 50
    ROW_HEADER = 51
    SCROLLBAR = 52
    SEARCH = 53
    SEARCH_BOX = 54
    SECTION = 55
    SECTION_HEAD = 56
    SELECT = 57
    SEPARATOR = 58
    SLIDER = 59
    SPIN_BUTTON = 60
    STATUS = 61
    STRUCTURE = 62
    SWITCH = 63
    TAB = 64
    TABLE = 65
    TAB_LIST = 66
    TAB_PANEL = 67
    TERMINAL = 84
    TEXT_BOX = 68
    TIME = 69
    TIMER = 70
    TOGGLE_BUTTON = 78
    TOOLBAR = 71
    TOOLTIP = 72
    TREE = 73
    TREE_GRID = 74
    TREE_ITEM = 75
    WIDGET = 76
    WINDOW = 77

class AccessibleSort(GObject.GEnum):
    ASCENDING = 1
    DESCENDING = 2
    NONE = 0
    OTHER = 3

class AccessibleState(GObject.GEnum):
    BUSY = 0
    CHECKED = 1
    DISABLED = 2
    EXPANDED = 3
    HIDDEN = 4
    INVALID = 5
    PRESSED = 6
    SELECTED = 7
    VISITED = 8
    @staticmethod
    def init_value(state: AccessibleState, value: typing.Any) -> None: ...

class AccessibleTextContentChange(GObject.GEnum):
    INSERT = 0
    REMOVE = 1

class AccessibleTextGranularity(GObject.GEnum):
    CHARACTER = 0
    LINE = 3
    PARAGRAPH = 4
    SENTENCE = 2
    WORD = 1

class AccessibleTristate(GObject.GEnum):
    FALSE = 0
    MIXED = 2
    TRUE = 1

class Align(GObject.GEnum):
    BASELINE = 4
    BASELINE_CENTER = 5
    BASELINE_FILL = 4
    CENTER = 3
    END = 2
    FILL = 0
    START = 1

class ArrowType(GObject.GEnum):
    DOWN = 1
    LEFT = 2
    NONE = 4
    RIGHT = 3
    UP = 0

class AssistantPageType(GObject.GEnum):
    CONFIRM = 2
    CONTENT = 0
    CUSTOM = 5
    INTRO = 1
    PROGRESS = 4
    SUMMARY = 3

class BaselinePosition(GObject.GEnum):
    BOTTOM = 2
    CENTER = 1
    TOP = 0

class BorderStyle(GObject.GEnum):
    DASHED = 6
    DOTTED = 5
    DOUBLE = 7
    GROOVE = 8
    HIDDEN = 1
    INSET = 3
    NONE = 0
    OUTSET = 4
    RIDGE = 9
    SOLID = 2

class BuilderError(GObject.GEnum):
    DUPLICATE_ID = 8
    INVALID_ATTRIBUTE = 3
    INVALID_FUNCTION = 14
    INVALID_ID = 13
    INVALID_PROPERTY = 11
    INVALID_SIGNAL = 12
    INVALID_TAG = 4
    INVALID_TYPE_FUNCTION = 0
    INVALID_VALUE = 6
    MISSING_ATTRIBUTE = 2
    MISSING_PROPERTY_VALUE = 5
    OBJECT_TYPE_REFUSED = 9
    TEMPLATE_MISMATCH = 10
    UNHANDLED_TAG = 1
    VERSION_MISMATCH = 7
    @staticmethod
    def quark() -> int: ...

class ButtonsType(GObject.GEnum):
    CANCEL = 3
    CLOSE = 2
    NONE = 0
    OK = 1
    OK_CANCEL = 5
    YES_NO = 4

class CellRendererAccelMode(GObject.GEnum):
    GTK = 0
    OTHER = 1

class CellRendererMode(GObject.GEnum):
    ACTIVATABLE = 1
    EDITABLE = 2
    INERT = 0

class Collation(GObject.GEnum):
    FILENAME = 2
    NONE = 0
    UNICODE = 1

class ConstraintAttribute(GObject.GEnum):
    BASELINE = 11
    BOTTOM = 4
    CENTER_X = 9
    CENTER_Y = 10
    END = 6
    HEIGHT = 8
    LEFT = 1
    NONE = 0
    RIGHT = 2
    START = 5
    TOP = 3
    WIDTH = 7

class ConstraintRelation(GObject.GEnum):
    EQ = 0
    GE = 1
    LE = -1

class ConstraintStrength(GObject.GEnum):
    MEDIUM = 1000
    REQUIRED = 1001001000
    STRONG = 1000000000
    WEAK = 1

class ConstraintVflParserError(GObject.GEnum):
    ATTRIBUTE = 1
    METRIC = 3
    PRIORITY = 4
    RELATION = 5
    SYMBOL = 0
    VIEW = 2
    @staticmethod
    def quark() -> int: ...

class ContentFit(GObject.GEnum):
    CONTAIN = 1
    COVER = 2
    FILL = 0
    SCALE_DOWN = 3

class CornerType(GObject.GEnum):
    BOTTOM_LEFT = 1
    BOTTOM_RIGHT = 3
    TOP_LEFT = 0
    TOP_RIGHT = 2

class CssParserError(GObject.GEnum):
    FAILED = 0
    IMPORT = 2
    NAME = 3
    SYNTAX = 1
    UNKNOWN_VALUE = 4

class CssParserWarning(GObject.GEnum):
    DEPRECATED = 0
    SYNTAX = 1
    UNIMPLEMENTED = 2

class DeleteType(GObject.GEnum):
    CHARS = 0
    DISPLAY_LINES = 3
    DISPLAY_LINE_ENDS = 4
    PARAGRAPHS = 6
    PARAGRAPH_ENDS = 5
    WHITESPACE = 7
    WORDS = 2
    WORD_ENDS = 1

class DialogError(GObject.GEnum):
    CANCELLED = 1
    DISMISSED = 2
    FAILED = 0
    @staticmethod
    def quark() -> int: ...

class DirectionType(GObject.GEnum):
    DOWN = 3
    LEFT = 4
    RIGHT = 5
    TAB_BACKWARD = 1
    TAB_FORWARD = 0
    UP = 2

class EditableProperties(GObject.GEnum):
    NUM_PROPERTIES = 8
    PROP_CURSOR_POSITION = 1
    PROP_EDITABLE = 3
    PROP_ENABLE_UNDO = 7
    PROP_MAX_WIDTH_CHARS = 5
    PROP_SELECTION_BOUND = 2
    PROP_TEXT = 0
    PROP_WIDTH_CHARS = 4
    PROP_XALIGN = 6

class EntryIconPosition(GObject.GEnum):
    PRIMARY = 0
    SECONDARY = 1

class EventSequenceState(GObject.GEnum):
    CLAIMED = 1
    DENIED = 2
    NONE = 0

class FileChooserAction(GObject.GEnum):
    OPEN = 0
    SAVE = 1
    SELECT_FOLDER = 2

class FileChooserError(GObject.GEnum):
    ALREADY_EXISTS = 2
    BAD_FILENAME = 1
    INCOMPLETE_HOSTNAME = 3
    NONEXISTENT = 0
    @staticmethod
    def quark() -> int: ...

class FilterChange(GObject.GEnum):
    DIFFERENT = 0
    DIFFERENT_REWATCH = 3
    LESS_STRICT = 1
    LESS_STRICT_REWATCH = 4
    MORE_STRICT = 2
    MORE_STRICT_REWATCH = 5

class FilterMatch(GObject.GEnum):
    ALL = 2
    NONE = 1
    SOME = 0

class FontLevel(GObject.GEnum):
    FACE = 1
    FAMILY = 0
    FEATURES = 3
    FONT = 2

class FontRendering(GObject.GEnum):
    AUTOMATIC = 0
    MANUAL = 1

class GraphicsOffloadEnabled(GObject.GEnum):
    DISABLED = 1
    ENABLED = 0

class IconSize(GObject.GEnum):
    INHERIT = 0
    LARGE = 2
    NORMAL = 1

class IconThemeError(GObject.GEnum):
    FAILED = 1
    NOT_FOUND = 0
    @staticmethod
    def quark() -> int: ...

class IconViewDropPosition(GObject.GEnum):
    DROP_ABOVE = 4
    DROP_BELOW = 5
    DROP_INTO = 1
    DROP_LEFT = 2
    DROP_RIGHT = 3
    NO_DROP = 0

class ImageType(GObject.GEnum):
    EMPTY = 0
    GICON = 2
    ICON_NAME = 1
    PAINTABLE = 3

class InputPurpose(GObject.GEnum):
    ALPHA = 1
    DIGITS = 2
    EMAIL = 6
    FREE_FORM = 0
    NAME = 7
    NUMBER = 3
    PASSWORD = 8
    PHONE = 4
    PIN = 9
    TERMINAL = 10
    URL = 5

class InscriptionOverflow(GObject.GEnum):
    CLIP = 0
    ELLIPSIZE_END = 3
    ELLIPSIZE_MIDDLE = 2
    ELLIPSIZE_START = 1

class InterfaceColorScheme(GObject.GEnum):
    DARK = 2
    DEFAULT = 1
    LIGHT = 3
    UNSUPPORTED = 0

class InterfaceContrast(GObject.GEnum):
    LESS = 3
    MORE = 2
    NO_PREFERENCE = 1
    UNSUPPORTED = 0

class Justification(GObject.GEnum):
    CENTER = 2
    FILL = 3
    LEFT = 0
    RIGHT = 1

class LevelBarMode(GObject.GEnum):
    CONTINUOUS = 0
    DISCRETE = 1

class License(GObject.GEnum):
    AGPL_3_0 = 13
    AGPL_3_0_ONLY = 14
    APACHE_2_0 = 16
    ARTISTIC = 8
    BSD = 6
    BSD_3 = 15
    CUSTOM = 1
    GPL_2_0 = 2
    GPL_2_0_ONLY = 9
    GPL_3_0 = 3
    GPL_3_0_ONLY = 10
    LGPL_2_1 = 4
    LGPL_2_1_ONLY = 11
    LGPL_3_0 = 5
    LGPL_3_0_ONLY = 12
    MIT_X11 = 7
    MPL_2_0 = 17
    UNKNOWN = 0

class ListTabBehavior(GObject.GEnum):
    ALL = 0
    CELL = 2
    ITEM = 1

class MessageType(GObject.GEnum):
    ERROR = 3
    INFO = 0
    OTHER = 4
    QUESTION = 2
    WARNING = 1

class MovementStep(GObject.GEnum):
    BUFFER_ENDS = 8
    DISPLAY_LINES = 3
    DISPLAY_LINE_ENDS = 4
    HORIZONTAL_PAGES = 9
    LOGICAL_POSITIONS = 0
    PAGES = 7
    PARAGRAPHS = 5
    PARAGRAPH_ENDS = 6
    VISUAL_POSITIONS = 1
    WORDS = 2

class NaturalWrapMode(GObject.GEnum):
    INHERIT = 0
    NONE = 1
    WORD = 2

class NotebookTab(GObject.GEnum):
    FIRST = 0
    LAST = 1

class NumberUpLayout(GObject.GEnum):
    BTLR = 6
    BTRL = 7
    LRBT = 1
    LRTB = 0
    RLBT = 3
    RLTB = 2
    TBLR = 4
    TBRL = 5

class Ordering(GObject.GEnum):
    EQUAL = 0
    LARGER = 1
    SMALLER = -1

class Orientation(GObject.GEnum):
    HORIZONTAL = 0
    VERTICAL = 1

class Overflow(GObject.GEnum):
    HIDDEN = 1
    VISIBLE = 0

class PackType(GObject.GEnum):
    END = 1
    START = 0

class PadActionType(GObject.GEnum):
    BUTTON = 0
    DIAL = 3
    RING = 1
    STRIP = 2

class PageOrientation(GObject.GEnum):
    LANDSCAPE = 1
    PORTRAIT = 0
    REVERSE_LANDSCAPE = 3
    REVERSE_PORTRAIT = 2

class PageSet(GObject.GEnum):
    ALL = 0
    EVEN = 1
    ODD = 2

class PanDirection(GObject.GEnum):
    DOWN = 3
    LEFT = 0
    RIGHT = 1
    UP = 2

class PolicyType(GObject.GEnum):
    ALWAYS = 0
    AUTOMATIC = 1
    EXTERNAL = 3
    NEVER = 2

class PositionType(GObject.GEnum):
    BOTTOM = 3
    LEFT = 0
    RIGHT = 1
    TOP = 2

class PrintDuplex(GObject.GEnum):
    HORIZONTAL = 1
    SIMPLEX = 0
    VERTICAL = 2

class PrintError(GObject.GEnum):
    GENERAL = 0
    INTERNAL_ERROR = 1
    INVALID_FILE = 3
    NOMEM = 2
    @staticmethod
    def quark() -> int: ...

class PrintOperationAction(GObject.GEnum):
    EXPORT = 3
    PREVIEW = 2
    PRINT = 1
    PRINT_DIALOG = 0

class PrintOperationResult(GObject.GEnum):
    APPLY = 1
    CANCEL = 2
    ERROR = 0
    IN_PROGRESS = 3

class PrintPages(GObject.GEnum):
    ALL = 0
    CURRENT = 1
    RANGES = 2
    SELECTION = 3

class PrintQuality(GObject.GEnum):
    DRAFT = 3
    HIGH = 2
    LOW = 0
    NORMAL = 1

class PrintStatus(GObject.GEnum):
    FINISHED = 7
    FINISHED_ABORTED = 8
    GENERATING_DATA = 2
    INITIAL = 0
    PENDING = 4
    PENDING_ISSUE = 5
    PREPARING = 1
    PRINTING = 6
    SENDING_DATA = 3

class PropagationLimit(GObject.GEnum):
    NONE = 0
    SAME_NATIVE = 1

class PropagationPhase(GObject.GEnum):
    BUBBLE = 2
    CAPTURE = 1
    NONE = 0
    TARGET = 3

class RecentManagerError(GObject.GEnum):
    INVALID_ENCODING = 2
    INVALID_URI = 1
    NOT_FOUND = 0
    NOT_REGISTERED = 3
    READ = 4
    UNKNOWN = 6
    WRITE = 5
    @staticmethod
    def quark() -> int: ...

class ResponseType(GObject.GEnum):
    ACCEPT = -3
    APPLY = -10
    CANCEL = -6
    CLOSE = -7
    DELETE_EVENT = -4
    HELP = -11
    NO = -9
    NONE = -1
    OK = -5
    REJECT = -2
    YES = -8

class RevealerTransitionType(GObject.GEnum):
    CROSSFADE = 1
    NONE = 0
    SLIDE_DOWN = 5
    SLIDE_LEFT = 3
    SLIDE_RIGHT = 2
    SLIDE_UP = 4
    SWING_DOWN = 9
    SWING_LEFT = 7
    SWING_RIGHT = 6
    SWING_UP = 8

class ScrollStep(GObject.GEnum):
    ENDS = 2
    HORIZONTAL_ENDS = 5
    HORIZONTAL_PAGES = 4
    HORIZONTAL_STEPS = 3
    PAGES = 1
    STEPS = 0

class ScrollType(GObject.GEnum):
    END = 15
    JUMP = 1
    NONE = 0
    PAGE_BACKWARD = 4
    PAGE_DOWN = 9
    PAGE_FORWARD = 5
    PAGE_LEFT = 12
    PAGE_RIGHT = 13
    PAGE_UP = 8
    START = 14
    STEP_BACKWARD = 2
    STEP_DOWN = 7
    STEP_FORWARD = 3
    STEP_LEFT = 10
    STEP_RIGHT = 11
    STEP_UP = 6

class ScrollablePolicy(GObject.GEnum):
    MINIMUM = 0
    NATURAL = 1

class SelectionMode(GObject.GEnum):
    BROWSE = 2
    MULTIPLE = 3
    NONE = 0
    SINGLE = 1

class SensitivityType(GObject.GEnum):
    AUTO = 0
    OFF = 2
    ON = 1

class ShortcutScope(GObject.GEnum):
    GLOBAL = 2
    LOCAL = 0
    MANAGED = 1

class ShortcutType(GObject.GEnum):
    ACCELERATOR = 0
    GESTURE = 7
    GESTURE_PINCH = 1
    GESTURE_ROTATE_CLOCKWISE = 3
    GESTURE_ROTATE_COUNTERCLOCKWISE = 4
    GESTURE_STRETCH = 2
    GESTURE_SWIPE_LEFT = 8
    GESTURE_SWIPE_RIGHT = 9
    GESTURE_TWO_FINGER_SWIPE_LEFT = 5
    GESTURE_TWO_FINGER_SWIPE_RIGHT = 6

class SizeGroupMode(GObject.GEnum):
    BOTH = 3
    HORIZONTAL = 1
    NONE = 0
    VERTICAL = 2

class SizeRequestMode(GObject.GEnum):
    CONSTANT_SIZE = 2
    HEIGHT_FOR_WIDTH = 0
    WIDTH_FOR_HEIGHT = 1

class SortType(GObject.GEnum):
    ASCENDING = 0
    DESCENDING = 1

class SorterChange(GObject.GEnum):
    DIFFERENT = 0
    INVERTED = 1
    LESS_STRICT = 2
    MORE_STRICT = 3

class SorterOrder(GObject.GEnum):
    NONE = 1
    PARTIAL = 0
    TOTAL = 2

class SpinButtonUpdatePolicy(GObject.GEnum):
    ALWAYS = 0
    IF_VALID = 1

class SpinType(GObject.GEnum):
    END = 5
    HOME = 4
    PAGE_BACKWARD = 3
    PAGE_FORWARD = 2
    STEP_BACKWARD = 1
    STEP_FORWARD = 0
    USER_DEFINED = 6

class StackTransitionType(GObject.GEnum):
    CROSSFADE = 1
    NONE = 0
    OVER_DOWN = 9
    OVER_DOWN_UP = 17
    OVER_LEFT = 10
    OVER_LEFT_RIGHT = 18
    OVER_RIGHT = 11
    OVER_RIGHT_LEFT = 19
    OVER_UP = 8
    OVER_UP_DOWN = 16
    ROTATE_LEFT = 20
    ROTATE_LEFT_RIGHT = 22
    ROTATE_RIGHT = 21
    SLIDE_DOWN = 5
    SLIDE_LEFT = 3
    SLIDE_LEFT_RIGHT = 6
    SLIDE_RIGHT = 2
    SLIDE_UP = 4
    SLIDE_UP_DOWN = 7
    UNDER_DOWN = 13
    UNDER_LEFT = 14
    UNDER_RIGHT = 15
    UNDER_UP = 12

class StringFilterMatchMode(GObject.GEnum):
    EXACT = 0
    PREFIX = 2
    SUBSTRING = 1

class SymbolicColor(GObject.GEnum):
    ERROR = 1
    FOREGROUND = 0
    SUCCESS = 3
    WARNING = 2

class SystemSetting(GObject.GEnum):
    DISPLAY = 3
    DPI = 0
    FONT_CONFIG = 2
    FONT_NAME = 1
    ICON_THEME = 4

class TextDirection(GObject.GEnum):
    LTR = 1
    NONE = 0
    RTL = 2

class TextExtendSelection(GObject.GEnum):
    LINE = 1
    WORD = 0

class TextViewLayer(GObject.GEnum):
    ABOVE_TEXT = 1
    BELOW_TEXT = 0

class TextWindowType(GObject.GEnum):
    BOTTOM = 6
    LEFT = 3
    RIGHT = 4
    TEXT = 2
    TOP = 5
    WIDGET = 1

class TreeViewColumnSizing(GObject.GEnum):
    AUTOSIZE = 1
    FIXED = 2
    GROW_ONLY = 0

class TreeViewDropPosition(GObject.GEnum):
    AFTER = 1
    BEFORE = 0
    INTO_OR_AFTER = 3
    INTO_OR_BEFORE = 2

class TreeViewGridLines(GObject.GEnum):
    BOTH = 3
    HORIZONTAL = 1
    NONE = 0
    VERTICAL = 2

class Unit(GObject.GEnum):
    INCH = 2
    MM = 3
    NONE = 0
    POINTS = 1

class WindowGravity(GObject.GEnum):
    BOTTOM = 7
    BOTTOM_END = 14
    BOTTOM_LEFT = 6
    BOTTOM_RIGHT = 8
    BOTTOM_START = 13
    CENTER = 4
    END = 12
    LEFT = 3
    RIGHT = 5
    START = 11
    TOP = 1
    TOP_END = 10
    TOP_LEFT = 0
    TOP_RIGHT = 2
    TOP_START = 9

class WrapMode(GObject.GEnum):
    CHAR = 1
    NONE = 0
    WORD = 2
    WORD_CHAR = 3
