@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,529 +1,1780 @@
+/** The priority of an accessibility announcement. */
 export declare enum AccessibleAnnouncementPriority {
+    /**
+     * The announcement is low priority,
+     * and might be read only on the user's request.
+     */
     LOW = 0,
+    /**
+     * The announcement is of medium
+     * priority, and is usually spoken at the next opportunity, such as at the
+     * end of speaking the current sentence or when the user pauses typing.
+     */
     MEDIUM = 1,
+    /**
+     * The announcement is of high
+     * priority, and is usually spoken immediately. Because an interruption
+     * might disorient users or cause them to not complete their current task,
+     * authors SHOULD NOT use high priority announcements unless the
+     * interruption is imperative. An example would be a notification about a
+     * critical battery power level.
+     */
     HIGH = 2
 }
+/**
+ * The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE
+ * accessible property.
+ */
 export declare enum AccessibleAutocomplete {
+    /** Automatic suggestions are not displayed. */
     NONE = 0,
+    /**
+     * When a user is providing input, text
+     * suggesting one way to complete the provided input may be dynamically
+     * inserted after the caret.
+     */
     INLINE = 1,
+    /**
+     * When a user is providing input, an element
+     * containing a collection of values that could complete the provided input
+     * may be displayed.
+     */
     LIST = 2,
+    /**
+     * When a user is providing input, an element
+     * containing a collection of values that could complete the provided input
+     * may be displayed. If displayed, one value in the collection is automatically
+     * selected, and the text needed to complete the automatically selected value
+     * appears after the caret in the input.
+     */
     BOTH = 3
 }
+/**
+ * The possible values for the %GTK_ACCESSIBLE_STATE_INVALID
+ * accessible state.
+ *
+ * Note that the %GTK_ACCESSIBLE_INVALID_FALSE and
+ * %GTK_ACCESSIBLE_INVALID_TRUE have the same values
+ * as %FALSE and %TRUE.
+ */
 export declare enum AccessibleInvalidState {
+    /** There are no detected errors in the value */
     FALSE = 0,
+    /** The value entered by the user has failed validation */
     TRUE = 1,
+    /** A grammatical error was detected */
     GRAMMAR = 2,
+    /** A spelling error was detected */
     SPELLING = 3
 }
+/**
+ * The various platform states which can be queried
+ * using [method@Gtk.Accessible.get_platform_state].
+ */
 export declare enum AccessiblePlatformState {
+    /** whether the accessible can be focused */
     FOCUSABLE = 0,
+    /** whether the accessible has focus */
     FOCUSED = 1,
+    /** whether the accessible is active */
     ACTIVE = 2
 }
+/** The possible accessible properties of a [iface@Accessible]. */
 export declare enum AccessibleProperty {
+    /**
+     * Indicates whether inputting text
+     * could trigger display of one or more predictions of the user's intended
+     * value for a combobox, searchbox, or textbox and specifies how predictions
+     * would be presented if they were made. Value type: [enum@AccessibleAutocomplete]
+     */
     AUTOCOMPLETE = 0,
+    /**
+     * Defines a string value that describes
+     * or annotates the current element. Value type: string
+     */
     DESCRIPTION = 1,
+    /**
+     * Indicates the availability and type of
+     * interactive popup element, such as menu or dialog, that can be triggered
+     * by an element.
+     */
     HAS_POPUP = 2,
+    /**
+     * Indicates keyboard shortcuts that an
+     * author has implemented to activate or give focus to an element. Value type:
+     * string. The format of the value is a space-separated list of shortcuts, with
+     * each shortcut consisting of one or more modifiers (`Control`, `Alt` or `Shift`),
+     * followed by a non-modifier key, all separated by `+`.
+     * Examples: `F2`, `Alt-F`, `Control+Shift+N`
+     */
     KEY_SHORTCUTS = 3,
+    /**
+     * Defines a string value that labels the current
+     * element. Value type: string
+     */
     LABEL = 4,
+    /**
+     * Defines the hierarchical level of an element
+     * within a structure. Value type: integer
+     */
     LEVEL = 5,
+    /**
+     * Indicates whether an element is modal when
+     * displayed. Value type: boolean
+     */
     MODAL = 6,
+    /**
+     * Indicates whether a text box accepts
+     * multiple lines of input or only a single line. Value type: boolean
+     */
     MULTI_LINE = 7,
+    /**
+     * Indicates that the user may select
+     * more than one item from the current selectable descendants. Value type:
+     * boolean
+     */
     MULTI_SELECTABLE = 8,
+    /**
+     * Indicates whether the element's
+     * orientation is horizontal, vertical, or unknown/ambiguous. Value type:
+     * [enum@Orientation]
+     */
     ORIENTATION = 9,
+    /**
+     * Defines a short hint (a word or short
+     * phrase) intended to aid the user with data entry when the control has no
+     * value. A hint could be a sample value or a brief description of the expected
+     * format. Value type: string
+     */
     PLACEHOLDER = 10,
+    /**
+     * Indicates that the element is not editable,
+     * but is otherwise operable. Value type: boolean
+     */
     READ_ONLY = 11,
+    /**
+     * Indicates that user input is required on
+     * the element before a form may be submitted. Value type: boolean
+     */
     REQUIRED = 12,
+    /**
+     * Defines a human-readable,
+     * author-localized description for the role of an element. Value type: string
+     */
     ROLE_DESCRIPTION = 13,
+    /**
+     * Indicates if items in a table or grid are
+     * sorted in ascending or descending order. Value type: [enum@AccessibleSort]
+     */
     SORT = 14,
+    /**
+     * Defines the maximum allowed value for a
+     * range widget. Value type: double
+     */
     VALUE_MAX = 15,
+    /**
+     * Defines the minimum allowed value for a
+     * range widget. Value type: double
+     */
     VALUE_MIN = 16,
+    /**
+     * Defines the current value for a range widget.
+     * Value type: double
+     */
     VALUE_NOW = 17,
+    /**
+     * Defines the human readable text alternative
+     * of [enum@Gtk.AccessibleProperty.VALUE_NOW] for a range widget. Value type: string
+     */
     VALUE_TEXT = 18,
+    /**
+     * Defines a string value that provides a description of non-standard keyboard
+     * interactions of the current element. Value type: string
+     */
     HELP_TEXT = 19
 }
+/**
+ * The possible accessible relations of a [iface@Accessible].
+ *
+ * Accessible relations can be references to other widgets,
+ * integers or strings.
+ */
 export declare enum AccessibleRelation {
+    /**
+     * Identifies the currently active
+     * element when focus is on a composite widget, combobox, textbox, group,
+     * or application. Value type: reference
+     */
     ACTIVE_DESCENDANT = 0,
+    /**
+     * Defines the total number of columns
+     * in a table, grid, or treegrid. Value type: integer
+     */
     COL_COUNT = 1,
+    /**
+     * Defines an element's column index or
+     * position with respect to the total number of columns within a table,
+     * grid, or treegrid. Value type: integer
+     */
     COL_INDEX = 2,
+    /**
+     * Defines a human readable text
+     * alternative of %GTK_ACCESSIBLE_RELATION_COL_INDEX. Value type: string
+     */
     COL_INDEX_TEXT = 3,
+    /**
+     * Defines the number of columns spanned
+     * by a cell or gridcell within a table, grid, or treegrid. Value type: integer
+     */
     COL_SPAN = 4,
+    /**
+     * Identifies the element (or elements) whose
+     * contents or presence are controlled by the current element. Value type: reference
+     */
     CONTROLS = 5,
+    /**
+     * Identifies the element (or elements)
+     * that describes the object. Value type: reference
+     */
     DESCRIBED_BY = 6,
+    /**
+     * Identifies the element (or elements) that
+     * provide additional information related to the object. Value type: reference
+     */
     DETAILS = 7,
+    /**
+     * Identifies the element (or elements) that
+     * provide an error message for an object. Value type: reference
+     */
     ERROR_MESSAGE = 8,
+    /**
+     * Identifies the next element (or elements)
+     * in an alternate reading order of content which, at the user's discretion,
+     * allows assistive technology to override the general default of reading in
+     * document source order. Value type: reference
+     */
     FLOW_TO = 9,
+    /**
+     * Identifies the element (or elements)
+     * that labels the current element. Value type: reference
+     */
     LABELLED_BY = 10,
+    /**
+     * Identifies an element (or elements) in order
+     * to define a visual, functional, or contextual parent/child relationship
+     * between elements where the widget hierarchy cannot be used to represent
+     * the relationship. Value type: reference
+     */
     OWNS = 11,
+    /**
+     * Defines an element's number or position
+     * in the current set of listitems or treeitems. Value type: integer
+     */
     POS_IN_SET = 12,
+    /**
+     * Defines the total number of rows in a table,
+     * grid, or treegrid. Value type: integer
+     */
     ROW_COUNT = 13,
+    /**
+     * Defines an element's row index or position
+     * with respect to the total number of rows within a table, grid, or treegrid.
+     * Value type: integer
+     */
     ROW_INDEX = 14,
+    /**
+     * Defines a human readable text
+     * alternative of [enum@Gtk.AccessibleRelation.ROW_INDEX]. Value type: string
+     */
     ROW_INDEX_TEXT = 15,
+    /**
+     * Defines the number of rows spanned by a
+     * cell or gridcell within a table, grid, or treegrid. Value type: integer
+     */
     ROW_SPAN = 16,
+    /**
+     * Defines the number of items in the current
+     * set of listitems or treeitems. Value type: integer
+     */
     SET_SIZE = 17,
+    /**
+     * Identifies the element (or elements) that are labeled by the
+     * current element. Value type: reference
+     *
+     * This relation is managed by GTK and should not be set from application code.
+     */
     LABEL_FOR = 18,
+    /**
+     * Identifies the element (or elements) that are described by
+     * the current element. Value type: reference
+     *
+     * This relation is managed by GTK and should not be set from application code.
+     */
     DESCRIPTION_FOR = 19,
+    /**
+     * Identifies the element (or elements) that the current
+     * element is controlled by. Value type: reference
+     *
+     * This relation is managed by GTK and should not be set from application code.
+     */
     CONTROLLED_BY = 20,
+    /**
+     * Identifies the element (or elements) for which the current
+     * element provides additional information. Value type: reference
+     *
+     * This relation is managed by GTK and should not be set from application code.
+     */
     DETAILS_FOR = 21,
+    /**
+     * Identifies the element (or elements) for which the current
+     * element provides an error message. Value type: reference
+     *
+     * This relation is managed by GTK and should not be set from application code.
+     */
     ERROR_MESSAGE_FOR = 22,
+    /**
+     * Identifies the previous element (or elements) in an alternate
+     * reading order of content which, at the user's discretion, allows
+     * assistive technology to override the general default of reading in
+     * document source order. Value type: reference
+     *
+     * This relation is managed by GTK and should not be set from application code.
+     */
     FLOW_FROM = 23
 }
+/**
+ * The accessible role for a [iface@Accessible] implementation.
+ *
+ * Abstract roles are only used as part of the ontology; application
+ * developers must not use abstract roles in their code.
+ */
 export declare enum AccessibleRole {
+    /**
+     * An element with important, and usually
+     * time-sensitive, information
+     */
     ALERT = 0,
+    /**
+     * A type of dialog that contains an
+     * alert message
+     */
     ALERT_DIALOG = 1,
+    /** Unused */
     BANNER = 2,
+    /**
+     * An input element that allows for
+     * user-triggered actions when clicked or pressed
+     */
     BUTTON = 3,
+    /** Unused */
     CAPTION = 4,
+    /** Unused */
     CELL = 5,
+    /**
+     * A checkable input element that has
+     * three possible values: `true`, `false`, or `mixed`
+     */
     CHECKBOX = 6,
+    /** A header in a columned list. */
     COLUMN_HEADER = 7,
+    /**
+     * An input that controls another element,
+     * such as a list or a grid, that can dynamically pop up to help the user
+     * set the value of the input
+     */
     COMBO_BOX = 8,
+    /** Abstract role. */
     COMMAND = 9,
+    /** Abstract role. */
     COMPOSITE = 10,
+    /**
+     * A dialog is a window that is designed to interrupt
+     * the current processing of an application in order to prompt the user to enter
+     * information or require a response.
+     */
     DIALOG = 11,
+    /**
+     * Content that assistive technology users may want to
+     * browse in a reading mode.
+     */
     DOCUMENT = 12,
+    /** Unused */
     FEED = 13,
+    /** Unused */
     FORM = 14,
+    /**
+     * A nameless container that has no semantic meaning
+     * of its own. This is the role that GTK uses by default for widgets.
+     */
     GENERIC = 15,
+    /** A grid of items. */
     GRID = 16,
+    /** An item in a grid or tree grid. */
     GRID_CELL = 17,
+    /**
+     * An element that groups multiple related widgets. GTK uses
+     * this role for various containers, like [class@Gtk.HeaderBar] or [class@Gtk.Notebook].
+     */
     GROUP = 18,
+    /** Unused */
     HEADING = 19,
+    /** An image. */
     IMG = 20,
+    /** Abstract role. */
     INPUT = 21,
+    /** A visible name or caption for a user interface component. */
     LABEL = 22,
+    /** Abstract role. */
     LANDMARK = 23,
+    /** Unused */
     LEGEND = 24,
+    /** A clickable link. */
     LINK = 25,
+    /** A list of items. */
     LIST = 26,
+    /** Unused. */
     LIST_BOX = 27,
+    /** An item in a list. */
     LIST_ITEM = 28,
+    /** Unused */
     LOG = 29,
+    /** Unused */
     MAIN = 30,
+    /** Unused */
     MARQUEE = 31,
+    /** Unused */
     MATH = 32,
+    /** An element that represents a value within a known range. */
     METER = 33,
+    /** A menu. */
     MENU = 34,
+    /** A menubar. */
     MENU_BAR = 35,
+    /** An item in a menu. */
     MENU_ITEM = 36,
+    /** A check item in a menu. */
     MENU_ITEM_CHECKBOX = 37,
+    /** A radio item in a menu. */
     MENU_ITEM_RADIO = 38,
+    /** Unused */
     NAVIGATION = 39,
+    /**
+     * An element that is not represented to accessibility technologies.
+     * This role is synonymous to @GTK_ACCESSIBLE_ROLE_PRESENTATION.
+     */
     NONE = 40,
+    /** Unused */
     NOTE = 41,
+    /** Unused */
     OPTION = 42,
+    /**
+     * An element that is not represented to accessibility technologies.
+     * This role is synonymous to @GTK_ACCESSIBLE_ROLE_NONE.
+     */
     PRESENTATION = 43,
+    /**
+     * An element that displays the progress
+     * status for tasks that take a long time.
+     */
     PROGRESS_BAR = 44,
+    /**
+     * A checkable input in a group of radio roles,
+     * only one of which can be checked at a time.
+     */
     RADIO = 45,
+    /** Unused */
     RADIO_GROUP = 46,
+    /** Abstract role. */
     RANGE = 47,
+    /** Unused */
     REGION = 48,
+    /** A row in a columned list. */
     ROW = 49,
+    /** Unused */
     ROW_GROUP = 50,
+    /** Unused */
     ROW_HEADER = 51,
+    /**
+     * A graphical object that controls the scrolling
+     * of content within a viewing area, regardless of whether the content is fully
+     * displayed within the viewing area.
+     */
     SCROLLBAR = 52,
+    /** Unused */
     SEARCH = 53,
+    /**
+     * A type of textbox intended for specifying
+     * search criteria.
+     */
     SEARCH_BOX = 54,
+    /** Abstract role. */
     SECTION = 55,
+    /** Abstract role. */
     SECTION_HEAD = 56,
+    /** Abstract role. */
     SELECT = 57,
+    /**
+     * A divider that separates and distinguishes
+     * sections of content or groups of menuitems.
+     */
     SEPARATOR = 58,
+    /**
+     * A user input where the user selects a value
+     * from within a given range.
+     */
     SLIDER = 59,
+    /**
+     * A form of range that expects the user to
+     * select from among discrete choices.
+     */
     SPIN_BUTTON = 60,
+    /** Unused */
     STATUS = 61,
+    /** Abstract role. */
     STRUCTURE = 62,
+    /**
+     * A type of checkbox that represents on/off values,
+     * as opposed to checked/unchecked values.
+     */
     SWITCH = 63,
+    /** An item in a list of tab used for switching pages. */
     TAB = 64,
+    /** Unused */
     TABLE = 65,
+    /** A list of tabs for switching pages. */
     TAB_LIST = 66,
+    /** A page in a notebook or stack. */
     TAB_PANEL = 67,
+    /**
+     * A type of input that allows free-form text
+     * as its value.
+     */
     TEXT_BOX = 68,
+    /** Unused */
     TIME = 69,
+    /** Unused */
     TIMER = 70,
+    /** Unused */
     TOOLBAR = 71,
+    /** Unused */
     TOOLTIP = 72,
+    /** Unused */
     TREE = 73,
+    /** A treeview-like, columned list. */
     TREE_GRID = 74,
+    /** Unused */
     TREE_ITEM = 75,
+    /**
+     * Abstract role for interactive components of a
+     * graphical user interface
+     */
     WIDGET = 76,
+    /** Abstract role for windows. */
     WINDOW = 77,
+    /**
+     * A type of push button which stays pressed until depressed by a second
+     * activation.
+     */
     TOGGLE_BUTTON = 78,
+    /**
+     * A toplevel element of a graphical user interface.
+     *
+     * This is the role that GTK uses by default for windows.
+     */
     APPLICATION = 79,
+    /** A paragraph of content. */
     PARAGRAPH = 80,
+    /** A section of content that is quoted from another source. */
     BLOCK_QUOTE = 81,
+    /**
+     * A section of a page that consists of a composition that forms an independent
+     * part of a document, page, or site.
+     */
     ARTICLE = 82,
+    /** A comment contains content expressing reaction to other content. */
     COMMENT = 83,
+    /** A virtual terminal. */
     TERMINAL = 84
 }
+/**
+ * The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT
+ * accessible property.
+ */
 export declare enum AccessibleSort {
+    /** There is no defined sort applied to the column. */
     NONE = 0,
+    /** Items are sorted in ascending order by this column. */
     ASCENDING = 1,
+    /** Items are sorted in descending order by this column. */
     DESCENDING = 2,
+    /**
+     * A sort algorithm other than ascending or
+     * descending has been applied.
+     */
     OTHER = 3
 }
+/** The possible accessible states of a [iface@Accessible]. */
 export declare enum AccessibleState {
+    /** A “busy” state. This state has boolean values */
     BUSY = 0,
+    /**
+     * A “checked” state; indicates the current
+     * state of a [class@CheckButton]. Value type: [enum@AccessibleTristate]
+     */
     CHECKED = 1,
+    /**
+     * A “disabled” state; corresponds to the
+     * [property@Widget:sensitive] property. It indicates a UI element
+     * that is perceivable, but not editable or operable. Value type: boolean
+     */
     DISABLED = 2,
+    /**
+     * An “expanded” state; corresponds to the
+     * [property@Expander:expanded] property. Value type: boolean
+     * or undefined
+     */
     EXPANDED = 3,
+    /**
+     * A “hidden” state; corresponds to the
+     * [property@Widget:visible] property. You can use this state
+     * explicitly on UI elements that should not be exposed to an assistive
+     * technology. Value type: boolean
+     * See also: %GTK_ACCESSIBLE_STATE_DISABLED
+     */
     HIDDEN = 4,
+    /**
+     * An “invalid” state; set when a widget
+     * is showing an error. Value type: [enum@AccessibleInvalidState]
+     */
     INVALID = 5,
+    /**
+     * A “pressed” state; indicates the current
+     * state of a [class@ToggleButton]. Value type: [enum@AccessibleTristate]
+     * enumeration
+     */
     PRESSED = 6,
+    /**
+     * A “selected” state; set when a widget
+     * is selected. Value type: boolean or undefined
+     */
     SELECTED = 7,
+    /**
+     * Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
+     * Value type: boolean.
+     */
     VISITED = 8
 }
+/** The type of contents change operation. */
 export declare enum AccessibleTextContentChange {
+    /**
+     * contents change as the result of
+     * an insert operation
+     */
     INSERT = 0,
+    /**
+     * contents change as the result of
+     * a remove operation
+     */
     REMOVE = 1
 }
+/**
+ * The granularity for queries about the text contents of a [iface@Gtk.AccessibleText]
+ * implementation.
+ */
 export declare enum AccessibleTextGranularity {
+    /**
+     * Use the boundary between
+     * characters (including non-printing characters)
+     */
     CHARACTER = 0,
+    /**
+     * Use the boundary between words,
+     * starting from the beginning of the current word and ending at the
+     * beginning of the next word
+     */
     WORD = 1,
+    /**
+     * Use the boundary between
+     * sentences, starting from the beginning of the current sentence and
+     * ending at the beginning of the next sentence
+     */
     SENTENCE = 2,
+    /**
+     * Use the boundary between lines,
+     * starting from the beginning of the current line and ending at the
+     * beginning of the next line
+     */
     LINE = 3,
+    /**
+     * Use the boundary between
+     * paragraphs, starting from the beginning of the current paragraph and
+     * ending at the beginning of the next paragraph
+     */
     PARAGRAPH = 4
 }
+/**
+ * The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED
+ * accessible state.
+ *
+ * Note that the %GTK_ACCESSIBLE_TRISTATE_FALSE and
+ * %GTK_ACCESSIBLE_TRISTATE_TRUE have the same values
+ * as %FALSE and %TRUE.
+ */
 export declare enum AccessibleTristate {
+    /** The state is `false` */
     FALSE = 0,
+    /** The state is `true` */
     TRUE = 1,
+    /** The state is `mixed` */
     MIXED = 2
 }
+/**
+ * Controls how a widget deals with extra space in a single dimension.
+ *
+ * Alignment only matters if the widget receives a “too large” allocation,
+ * for example if you packed the widget with the [property@Gtk.Widget:hexpand]
+ * property inside a [class@Box], then the widget might get extra space.
+ * If you have for example a 16x16 icon inside a 32x32 space, the icon
+ * could be scaled and stretched, it could be centered, or it could be
+ * positioned to one side of the space.
+ *
+ * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
+ * are interpreted relative to text direction.
+ *
+ * Baseline support is optional for containers and widgets, and is only available
+ * for vertical alignment. `GTK_ALIGN_BASELINE_CENTER` and `GTK_ALIGN_BASELINE_FILL`
+ * are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
+ * positions the widget to line up the baselines, where that is supported.
+ */
 export declare enum Align {
+    /**
+     * stretch to fill all space if possible, center if
+     * no meaningful way to stretch
+     */
     FILL = 0,
+    /** snap to left or top side, leaving space on right or bottom */
     START = 1,
+    /** snap to right or bottom side, leaving space on left or top */
     END = 2,
+    /** center natural width of widget inside the allocation */
     CENTER = 3,
+    /** a different name for `GTK_ALIGN_BASELINE`. */
     BASELINE_FILL = 4,
+    /** align the widget according to the baseline. */
     BASELINE = 4,
+    /** stretch to fill all space, but align the baseline. */
     BASELINE_CENTER = 5
 }
+/** Indicates the direction in which an arrow should point. */
 export declare enum ArrowType {
+    /** Represents an upward pointing arrow. */
     UP = 0,
+    /** Represents a downward pointing arrow. */
     DOWN = 1,
+    /** Represents a left pointing arrow. */
     LEFT = 2,
+    /** Represents a right pointing arrow. */
     RIGHT = 3,
+    /** No arrow. */
     NONE = 4
 }
+/**
+ * Determines the role of a page inside a `GtkAssistant`.
+ *
+ * The role is used to handle buttons sensitivity and visibility.
+ *
+ * Note that an assistant needs to end its page flow with a page of type
+ * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
+ * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
+ *
+ * The Cancel button will only be shown if the page isn’t “committed”.
+ * See gtk_assistant_commit() for details.
+ */
 export declare enum AssistantPageType {
+    /**
+     * The page has regular contents. Both the
+     * Back and forward buttons will be shown.
+     */
     CONTENT = 0,
+    /**
+     * The page contains an introduction to the
+     * assistant task. Only the Forward button will be shown if there is a
+     * next page.
+     */
     INTRO = 1,
+    /**
+     * The page lets the user confirm or deny the
+     * changes. The Back and Apply buttons will be shown.
+     */
     CONFIRM = 2,
+    /**
+     * The page informs the user of the changes
+     * done. Only the Close button will be shown.
+     */
     SUMMARY = 3,
+    /**
+     * Used for tasks that take a long time to
+     * complete, blocks the assistant until the page is marked as complete.
+     * Only the back button will be shown.
+     */
     PROGRESS = 4,
+    /**
+     * Used for when other page types are not
+     * appropriate. No buttons will be shown, and the application must
+     * add its own buttons through gtk_assistant_add_action_widget().
+     */
     CUSTOM = 5
 }
+/**
+ * Baseline position in a row of widgets.
+ *
+ * Whenever a container has some form of natural row it may align
+ * children in that row along a common typographical baseline. If
+ * the amount of vertical space in the row is taller than the total
+ * requested height of the baseline-aligned children then it can use a
+ * `GtkBaselinePosition` to select where to put the baseline inside the
+ * extra available space.
+ */
 export declare enum BaselinePosition {
+    /** Align the baseline at the top */
     TOP = 0,
+    /** Center the baseline */
     CENTER = 1,
+    /** Align the baseline at the bottom */
     BOTTOM = 2
 }
+/** Describes how the border of a UI element should be rendered. */
 export declare enum BorderStyle {
+    /** No visible border */
     NONE = 0,
+    /** Same as %GTK_BORDER_STYLE_NONE */
     HIDDEN = 1,
+    /** A single line segment */
     SOLID = 2,
+    /** Looks as if the content is sunken into the canvas */
     INSET = 3,
+    /** Looks as if the content is coming out of the canvas */
     OUTSET = 4,
+    /** A series of round dots */
     DOTTED = 5,
+    /** A series of square-ended dashes */
     DASHED = 6,
+    /** Two parallel lines with some space between them */
     DOUBLE = 7,
+    /** Looks as if it were carved in the canvas */
     GROOVE = 8,
+    /** Looks as if it were coming out of the canvas */
     RIDGE = 9
 }
+/**
+ * Error codes that identify various errors that can occur while using
+ * `GtkBuilder`.
+ */
 export declare enum BuilderError {
+    /**
+     * A type-func attribute didn’t name
+     * a function that returns a `GType`.
+     */
     INVALID_TYPE_FUNCTION = 0,
+    /**
+     * The input contained a tag that `GtkBuilder`
+     * can’t handle.
+     */
     UNHANDLED_TAG = 1,
+    /**
+     * An attribute that is required by
+     * `GtkBuilder` was missing.
+     */
     MISSING_ATTRIBUTE = 2,
+    /**
+     * `GtkBuilder` found an attribute that
+     * it doesn’t understand.
+     */
     INVALID_ATTRIBUTE = 3,
+    /**
+     * `GtkBuilder` found a tag that
+     * it doesn’t understand.
+     */
     INVALID_TAG = 4,
+    /**
+     * A required property value was
+     * missing.
+     */
     MISSING_PROPERTY_VALUE = 5,
+    /**
+     * `GtkBuilder` couldn’t parse
+     * some attribute value.
+     */
     INVALID_VALUE = 6,
+    /**
+     * The input file requires a newer version
+     * of GTK.
+     */
     VERSION_MISMATCH = 7,
+    /** An object id occurred twice. */
     DUPLICATE_ID = 8,
+    /**
+     * A specified object type is of the same type or
+     * derived from the type of the composite class being extended with builder XML.
+     */
     OBJECT_TYPE_REFUSED = 9,
+    /** The wrong type was specified in a composite class’s template XML */
     TEMPLATE_MISMATCH = 10,
+    /** The specified property is unknown for the object class. */
     INVALID_PROPERTY = 11,
+    /** The specified signal is unknown for the object class. */
     INVALID_SIGNAL = 12,
+    /** An object id is unknown. */
     INVALID_ID = 13,
+    /**
+     * A function could not be found. This often happens
+     * when symbols are set to be kept private. Compiling code with -rdynamic or using the
+     * `gmodule-export-2.0` pkgconfig module can fix this problem.
+     */
     INVALID_FUNCTION = 14
 }
+/**
+ * Prebuilt sets of buttons for `GtkDialog`.
+ *
+ * If none of these choices are appropriate, simply use
+ * %GTK_BUTTONS_NONE and call [method@Gtk.Dialog.add_buttons].
+ *
+ * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
+ * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
+ * > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
+ */
 export declare enum ButtonsType {
+    /** no buttons at all */
     NONE = 0,
+    /** an OK button */
     OK = 1,
+    /** a Close button */
     CLOSE = 2,
+    /** a Cancel button */
     CANCEL = 3,
+    /** Yes and No buttons */
     YES_NO = 4,
+    /** OK and Cancel buttons */
     OK_CANCEL = 5
 }
+/** The available modes for [property@Gtk.CellRendererAccel:accel-mode]. */
 export declare enum CellRendererAccelMode {
+    /** GTK accelerators mode */
     GTK = 0,
+    /** Other accelerator mode */
     OTHER = 1
 }
+/** Identifies how the user can interact with a particular cell. */
 export declare enum CellRendererMode {
+    /**
+     * The cell is just for display
+     * and cannot be interacted with.  Note that this doesn’t mean that eg. the
+     * row being drawn can’t be selected -- just that a particular element of
+     * it cannot be individually modified.
+     */
     INERT = 0,
+    /** The cell can be clicked. */
     ACTIVATABLE = 1,
+    /** The cell can be edited or otherwise modified. */
     EDITABLE = 2
 }
+/**
+ * Describes how a [class@Gtk.StringSorter] turns strings into sort keys to
+ * compare them.
+ *
+ * Note that the result of sorting will in general depend on the current locale
+ * unless the mode is @GTK_COLLATION_NONE.
+ */
 export declare enum Collation {
+    /** Don't do any collation */
     NONE = 0,
+    /** Use [func@GLib.utf8_collate_key] */
     UNICODE = 1,
+    /** Use [func@GLib.utf8_collate_key_for_filename] */
     FILENAME = 2
 }
+/** The widget attributes that can be used when creating a [class@Constraint]. */
 export declare enum ConstraintAttribute {
+    /**
+     * No attribute, used for constant
+     * relations
+     */
     NONE = 0,
+    /**
+     * The left edge of a widget, regardless of
+     * text direction
+     */
     LEFT = 1,
+    /**
+     * The right edge of a widget, regardless
+     * of text direction
+     */
     RIGHT = 2,
+    /** The top edge of a widget */
     TOP = 3,
+    /** The bottom edge of a widget */
     BOTTOM = 4,
+    /**
+     * The leading edge of a widget, depending
+     * on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_LEFT for LTR
+     * languages, and %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for RTL ones
+     */
     START = 5,
+    /**
+     * The trailing edge of a widget, depending
+     * on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for LTR
+     * languages, and %GTK_CONSTRAINT_ATTRIBUTE_LEFT for RTL ones
+     */
     END = 6,
+    /** The width of a widget */
     WIDTH = 7,
+    /** The height of a widget */
     HEIGHT = 8,
+    /**
+     * The center of a widget, on the
+     * horizontal axis
+     */
     CENTER_X = 9,
+    /**
+     * The center of a widget, on the
+     * vertical axis
+     */
     CENTER_Y = 10,
+    /** The baseline of a widget */
     BASELINE = 11
 }
+/** The relation between two terms of a constraint. */
 export declare enum ConstraintRelation {
+    /** Less than, or equal */
     LE = -1,
+    /** Equal */
     EQ = 0,
+    /** Greater than, or equal */
     GE = 1
 }
+/**
+ * The strength of a constraint, expressed as a symbolic constant.
+ *
+ * The strength of a [class@Constraint] can be expressed with any positive
+ * integer; the values of this enumeration can be used for readability.
+ */
 export declare enum ConstraintStrength {
+    /** The constraint is required towards solving the layout */
     REQUIRED = 1001001000,
+    /** A strong constraint */
     STRONG = 1000000000,
+    /** A medium constraint */
     MEDIUM = 1000,
+    /** A weak constraint */
     WEAK = 1
 }
+/** Domain for VFL parsing errors. */
 export declare enum ConstraintVflParserError {
+    /** Invalid or unknown symbol */
     SYMBOL = 0,
+    /** Invalid or unknown attribute */
     ATTRIBUTE = 1,
+    /** Invalid or unknown view */
     VIEW = 2,
+    /** Invalid or unknown metric */
     METRIC = 3,
+    /** Invalid or unknown priority */
     PRIORITY = 4,
+    /** Invalid or unknown relation */
     RELATION = 5
 }
+/** Controls how a content should be made to fit inside an allocation. */
 export declare enum ContentFit {
+    /**
+     * Make the content fill the entire allocation,
+     * without taking its aspect ratio in consideration. The resulting
+     * content will appear as stretched if its aspect ratio is different
+     * from the allocation aspect ratio.
+     */
     FILL = 0,
+    /**
+     * Scale the content to fit the allocation,
+     * while taking its aspect ratio in consideration. The resulting
+     * content will appear as letterboxed if its aspect ratio is different
+     * from the allocation aspect ratio.
+     */
     CONTAIN = 1,
+    /**
+     * Cover the entire allocation, while taking
+     * the content aspect ratio in consideration. The resulting content
+     * will appear as clipped if its aspect ratio is different from the
+     * allocation aspect ratio.
+     */
     COVER = 2,
+    /**
+     * The content is scaled down to fit the
+     * allocation, if needed, otherwise its original size is used.
+     */
     SCALE_DOWN = 3
 }
+/**
+ * Specifies which corner a child widget should be placed in when packed into
+ * a `GtkScrolledWindow.`
+ *
+ * This is effectively the opposite of where the scroll bars are placed.
+ */
 export declare enum CornerType {
+    /**
+     * Place the scrollbars on the right and bottom of the
+     * widget (default behaviour).
+     */
     TOP_LEFT = 0,
+    /**
+     * Place the scrollbars on the top and right of the
+     * widget.
+     */
     BOTTOM_LEFT = 1,
+    /**
+     * Place the scrollbars on the left and bottom of the
+     * widget.
+     */
     TOP_RIGHT = 2,
+    /**
+     * Place the scrollbars on the top and left of the
+     * widget.
+     */
     BOTTOM_RIGHT = 3
 }
+/**
+ * Errors that can occur while parsing CSS.
+ *
+ * These errors are unexpected and will cause parts of the given CSS
+ * to be ignored.
+ */
 export declare enum CssParserError {
+    /** Unknown failure. */
     FAILED = 0,
+    /** The given text does not form valid syntax */
     SYNTAX = 1,
+    /** Failed to import a resource */
     IMPORT = 2,
+    /** The given name has not been defined */
     NAME = 3,
+    /** The given value is not correct */
     UNKNOWN_VALUE = 4
 }
+/**
+ * Warnings that can occur while parsing CSS.
+ *
+ * Unlike `GtkCssParserError`s, warnings do not cause the parser to
+ * skip any input, but they indicate issues that should be fixed.
+ */
 export declare enum CssParserWarning {
+    /**
+     * The given construct is
+     * deprecated and will be removed in a future version
+     */
     DEPRECATED = 0,
+    /**
+     * A syntax construct was used
+     * that should be avoided
+     */
     SYNTAX = 1,
+    /** A feature is not implemented */
     UNIMPLEMENTED = 2
 }
+/** Passed to various keybinding signals for deleting text. */
 export declare enum DeleteType {
+    /** Delete characters. */
     CHARS = 0,
+    /**
+     * Delete only the portion of the word to the
+     * left/right of cursor if we’re in the middle of a word.
+     */
     WORD_ENDS = 1,
+    /** Delete words. */
     WORDS = 2,
+    /**
+     * Delete display-lines. Display-lines
+     * refers to the visible lines, with respect to the current line
+     * breaks. As opposed to paragraphs, which are defined by line
+     * breaks in the input.
+     */
     DISPLAY_LINES = 3,
+    /**
+     * Delete only the portion of the
+     * display-line to the left/right of cursor.
+     */
     DISPLAY_LINE_ENDS = 4,
+    /**
+     * Delete to the end of the
+     * paragraph. Like C-k in Emacs (or its reverse).
+     */
     PARAGRAPH_ENDS = 5,
+    /** Delete entire line. Like C-k in pico. */
     PARAGRAPHS = 6,
+    /** Delete only whitespace. Like M-\ in Emacs. */
     WHITESPACE = 7
 }
+/**
+ * Error codes in the `GTK_DIALOG_ERROR` domain that can be returned
+ * by async dialog functions.
+ */
 export declare enum DialogError {
+    /**
+     * Generic error condition for when
+     * an operation fails and no more specific code is applicable
+     */
     FAILED = 0,
+    /**
+     * The async function call was cancelled
+     * via its `GCancellable`
+     */
     CANCELLED = 1,
+    /**
+     * The operation was cancelled
+     * by the user (via a Cancel or Close button)
+     */
     DISMISSED = 2
 }
+/** Focus movement types. */
 export declare enum DirectionType {
+    /** Move forward. */
     TAB_FORWARD = 0,
+    /** Move backward. */
     TAB_BACKWARD = 1,
+    /** Move up. */
     UP = 2,
+    /** Move down. */
     DOWN = 3,
+    /** Move left. */
     LEFT = 4,
+    /** Move right. */
     RIGHT = 5
 }
+/**
+ * The identifiers for [iface@Gtk.Editable] properties.
+ *
+ * See [func@Gtk.Editable.install_properties] for details on how to
+ * implement the `GtkEditable` interface.
+ */
 export declare enum EditableProperties {
+    /** the property id for [property@Gtk.Editable:text] */
     PROP_TEXT = 0,
+    /** the property id for [property@Gtk.Editable:cursor-position] */
     PROP_CURSOR_POSITION = 1,
+    /** the property id for [property@Gtk.Editable:selection-bound] */
     PROP_SELECTION_BOUND = 2,
+    /** the property id for [property@Gtk.Editable:editable] */
     PROP_EDITABLE = 3,
+    /** the property id for [property@Gtk.Editable:width-chars] */
     PROP_WIDTH_CHARS = 4,
+    /** the property id for [property@Gtk.Editable:max-width-chars] */
     PROP_MAX_WIDTH_CHARS = 5,
+    /** the property id for [property@Gtk.Editable:xalign] */
     PROP_XALIGN = 6,
+    /** the property id for [property@Gtk.Editable:enable-undo] */
     PROP_ENABLE_UNDO = 7,
+    /** the number of properties */
     NUM_PROPERTIES = 8
 }
+/** Specifies the side of the entry at which an icon is placed. */
 export declare enum EntryIconPosition {
+    /** At the beginning of the entry (depending on the text direction). */
     PRIMARY = 0,
+    /** At the end of the entry (depending on the text direction). */
     SECONDARY = 1
 }
+/** Describes the state of a [struct@Gdk.EventSequence] in a [class@Gesture]. */
 export declare enum EventSequenceState {
+    /** The sequence is handled, but not grabbed. */
     NONE = 0,
+    /** The sequence is handled and grabbed. */
     CLAIMED = 1,
+    /** The sequence is denied. */
     DENIED = 2
 }
+/**
+ * Describes whether a `GtkFileChooser` is being used to open existing files
+ * or to save to a possibly new file.
+ */
 export declare enum FileChooserAction {
+    /**
+     * Indicates open mode.  The file chooser
+     * will only let the user pick an existing file.
+     */
     OPEN = 0,
+    /**
+     * Indicates save mode.  The file chooser
+     * will let the user pick an existing file, or type in a new
+     * filename.
+     */
     SAVE = 1,
+    /**
+     * Indicates an Open mode for
+     * selecting folders.  The file chooser will let the user pick an
+     * existing folder.
+     */
     SELECT_FOLDER = 2
 }
+/**
+ * These identify the various errors that can occur while calling
+ * `GtkFileChooser` functions.
+ */
 export declare enum FileChooserError {
+    /** Indicates that a file does not exist. */
     NONEXISTENT = 0,
+    /** Indicates a malformed filename. */
     BAD_FILENAME = 1,
+    /**
+     * Indicates a duplicate path (e.g. when
+     * adding a bookmark).
+     */
     ALREADY_EXISTS = 2,
+    /**
+     * Indicates an incomplete hostname
+     * (e.g. "http://foo" without a slash after that).
+     */
     INCOMPLETE_HOSTNAME = 3
 }
+/**
+ * Describes changes in a filter in more detail and allows objects
+ * using the filter to optimize refiltering items.
+ *
+ * If you are writing an implementation and are not sure which
+ * value to pass, `GTK_FILTER_CHANGE_DIFFERENT` is always a correct
+ * choice.
+ *
+ * New values may be added in the future.
+ */
 export declare enum FilterChange {
+    /**
+     * The filter change cannot be
+     * described with any of the other enumeration values
+     */
     DIFFERENT = 0,
+    /**
+     * The filter is less strict than
+     * it was before: All items that it used to return true
+     * still return true, others now may, too.
+     */
     LESS_STRICT = 1,
+    /**
+     * The filter is more strict than
+     * it was before: All items that it used to return false
+     * still return false, others now may, too.
+     */
     MORE_STRICT = 2,
+    /**
+     * Similar to [enum@Gtk.FilterChange.DIFFERENT],
+     * but signs that item watches should be recreated. This is used by
+     * [class@Gtk.FilterListModel] to keep the list up-to-date when items
+     * change.
+     */
     DIFFERENT_REWATCH = 3,
+    /**
+     * Similar to [enum@Gtk.FilterChange.LESS_STRICT],
+     * but signs that item watches should be recreated. This is used by
+     * [class@Gtk.FilterListModel] to keep the list up-to-date when items
+     * change.
+     */
     LESS_STRICT_REWATCH = 4,
+    /**
+     * Similar to [enum@Gtk.FilterChange.MORE_STRICT],
+     * but signs that item watches should be recreated. This is used by
+     * [class@Gtk.FilterListModel] to keep the list up-to-date when items
+     * change.
+     */
     MORE_STRICT_REWATCH = 5
 }
+/**
+ * Describes the known strictness of a filter.
+ *
+ * Note that for filters where the strictness is not known,
+ * `GTK_FILTER_MATCH_SOME` is always an acceptable value,
+ * even if a filter does match all or no items.
+ */
 export declare enum FilterMatch {
+    /**
+     * The filter matches some items,
+     * [method@Gtk.Filter.match] may return true or false
+     */
     SOME = 0,
+    /**
+     * The filter does not match any item,
+     * [method@Gtk.Filter.match] will always return false
+     */
     NONE = 1,
+    /**
+     * The filter matches all items,
+     * [method@Gtk.Filter.match] will alays return true
+     */
     ALL = 2
 }
+/**
+ * The level of granularity for the font selection.
+ *
+ * Depending on this value, the `PangoFontDescription` that
+ * is returned by [method@Gtk.FontDialogButton.get_font_desc]
+ * will have more or less fields set.
+ */
 export declare enum FontLevel {
+    /** Select a font family */
     FAMILY = 0,
+    /** Select a font face (i.e. a family and a style) */
     FACE = 1,
+    /** Select a font (i.e. a face with a size, and possibly font variations) */
     FONT = 2,
+    /** Select a font and font features */
     FEATURES = 3
 }
+/**
+ * Values for the [property@Gtk.Settings:gtk-font-rendering] setting
+ * that influence how GTK renders fonts.
+ */
 export declare enum FontRendering {
+    /**
+     * Set up font rendering automatically,
+     * taking factors like screen resolution and scale into account
+     */
     AUTOMATIC = 0,
+    /**
+     * Follow low-level font-related settings
+     * when configuring font rendering
+     */
     MANUAL = 1
 }
+/** Represents the state of graphics offloading. */
 export declare enum GraphicsOffloadEnabled {
+    /** Graphics offloading is enabled. */
     ENABLED = 0,
+    /** Graphics offloading is disabled. */
     DISABLED = 1
 }
+/**
+ * Built-in icon sizes.
+ *
+ * Icon sizes default to being inherited. Where they cannot be
+ * inherited, text size is the default.
+ *
+ * All widgets which use `GtkIconSize` set the normal-icons or
+ * large-icons style classes correspondingly, and let themes
+ * determine the actual size to be used with the
+ * `-gtk-icon-size` CSS property.
+ */
 export declare enum IconSize {
+    /** Keep the size of the parent element */
     INHERIT = 0,
+    /** Size similar to text size */
     NORMAL = 1,
+    /** Large size, for example in an icon view */
     LARGE = 2
 }
+/** Error codes for `GtkIconTheme` operations. */
 export declare enum IconThemeError {
+    /** The icon specified does not exist in the theme */
     NOT_FOUND = 0,
+    /** An unspecified error occurred. */
     FAILED = 1
 }
+/** An enum for determining where a dropped item goes. */
 export declare enum IconViewDropPosition {
+    /** no drop possible */
     NO_DROP = 0,
+    /** dropped item replaces the item */
     DROP_INTO = 1,
+    /** dropped item is inserted to the left */
     DROP_LEFT = 2,
+    /** dropped item is inserted to the right */
     DROP_RIGHT = 3,
+    /** dropped item is inserted above */
     DROP_ABOVE = 4,
+    /** dropped item is inserted below */
     DROP_BELOW = 5
 }
+/**
+ * Describes the image data representation used by a [class@Gtk.Image].
+ *
+ * If you want to get the image from the widget, you can only get the
+ * currently-stored representation; for instance, if the gtk_image_get_storage_type()
+ * returns %GTK_IMAGE_PAINTABLE, then you can call gtk_image_get_paintable().
+ *
+ * For empty images, you can request any storage type (call any of the "get"
+ * functions), but they will all return %NULL values.
+ */
 export declare enum ImageType {
+    /** there is no image displayed by the widget */
     EMPTY = 0,
+    /** the widget contains a named icon */
     ICON_NAME = 1,
+    /** the widget contains a `GIcon` */
     GICON = 2,
+    /** the widget contains a `GdkPaintable` */
     PAINTABLE = 3
 }
+/**
+ * Describes primary purpose of the input widget.
+ *
+ * This information is useful for on-screen keyboards and similar input
+ * methods to decide which keys should be presented to the user.
+ *
+ * Note that the purpose is not meant to impose a totally strict rule
+ * about allowed characters, and does not replace input validation.
+ * It is fine for an on-screen keyboard to let the user override the
+ * character set restriction that is expressed by the purpose. The
+ * application is expected to validate the entry contents, even if
+ * it specified a purpose.
+ *
+ * The difference between %GTK_INPUT_PURPOSE_DIGITS and
+ * %GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
+ * while the latter also some punctuation (like commas or points, plus,
+ * minus) and “e” or “E” as in 3.14E+000.
+ *
+ * This enumeration may be extended in the future; input methods should
+ * interpret unknown values as “free form”.
+ */
 export declare enum InputPurpose {
+    /** Allow any character */
     FREE_FORM = 0,
+    /** Allow only alphabetic characters */
     ALPHA = 1,
+    /** Allow only digits */
     DIGITS = 2,
+    /** Edited field expects numbers */
     NUMBER = 3,
+    /** Edited field expects phone number */
     PHONE = 4,
+    /** Edited field expects URL */
     URL = 5,
+    /** Edited field expects email address */
     EMAIL = 6,
+    /** Edited field expects the name of a person */
     NAME = 7,
+    /** Like %GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden */
     PASSWORD = 8,
+    /** Like %GTK_INPUT_PURPOSE_DIGITS, but characters are hidden */
     PIN = 9,
+    /** Allow any character, in addition to control codes */
     TERMINAL = 10
 }
+/**
+ * The different methods to handle text in #GtkInscription when it doesn't
+ * fit the available space.
+ */
 export declare enum InscriptionOverflow {
+    /** Clip the remaining text */
     CLIP = 0,
+    /** Omit characters at the start of the text */
     ELLIPSIZE_START = 1,
+    /** Omit characters at the middle of the text */
     ELLIPSIZE_MIDDLE = 2,
+    /** Omit characters at the end of the text */
     ELLIPSIZE_END = 3
 }
+/**
+ * Values for the [property@Gtk.Settings:gtk-interface-color-scheme]
+ * and [property@Gtk.CssProvider:prefers-color-scheme] properties
+ * that indicates what color scheme is used.
+ *
+ * This information can be used inside CSS via media queries.
+ *
+ * More values may be added to this enumeration. Unknown values
+ * should be treated the same as `GTK_INTERFACE_COLOR_SCHEME_DEFAULT`.
+ */
 export declare enum InterfaceColorScheme {
+    /** The system doesn't support color schemes */
     UNSUPPORTED = 0,
+    /** The default color scheme is used */
     DEFAULT = 1,
+    /** A dark color scheme is used */
     DARK = 2,
+    /** A light color scheme is used */
     LIGHT = 3
 }
+/**
+ * Values for the [property@Gtk.Settings:gtk-interface-contrast]
+ * and [property@Gtk.CssProvider:prefers-contrast] properties
+ * that indicates the preferred level of contrast.
+ *
+ * This information can be used inside CSS via media queries.
+ *
+ * More values may be added to this enumeration. Unknown values
+ * should be treated the same as `GTK_INTERFACE_CONTRAST_NO_PREFERENCE`.
+ */
 export declare enum InterfaceContrast {
+    /** The system doesn't support contrast levels */
     UNSUPPORTED = 0,
+    /** No particular preference for contrast */
     NO_PREFERENCE = 1,
+    /** More contrast is preferred */
     MORE = 2,
+    /** Less contrast is preferred */
     LESS = 3
 }
+/** Used for justifying the text inside a [class@Label] widget. */
 export declare enum Justification {
+    /** The text is placed at the left edge of the label. */
     LEFT = 0,
+    /** The text is placed at the right edge of the label. */
     RIGHT = 1,
+    /** The text is placed in the center of the label. */
     CENTER = 2,
+    /** The text is placed is distributed across the label. */
     FILL = 3
 }
+/**
+ * Describes how [class@LevelBar] contents should be rendered.
+ *
+ * Note that this enumeration could be extended with additional modes
+ * in the future.
+ */
 export declare enum LevelBarMode {
+    /** the bar has a continuous mode */
     CONTINUOUS = 0,
+    /** the bar has a discrete mode */
     DISCRETE = 1
 }
+/**
+ * The type of license for an application.
+ *
+ * This enumeration can be expanded at later date.
+ */
 export declare enum License {
+    /** No license specified */
     UNKNOWN = 0,
+    /**
+     * A license text is going to be specified by the
+     * developer
+     */
     CUSTOM = 1,
+    /** The GNU General Public License, version 2.0 or later */
     GPL_2_0 = 2,
+    /** The GNU General Public License, version 3.0 or later */
     GPL_3_0 = 3,
+    /** The GNU Lesser General Public License, version 2.1 or later */
     LGPL_2_1 = 4,
+    /** The GNU Lesser General Public License, version 3.0 or later */
     LGPL_3_0 = 5,
+    /** The BSD standard license */
     BSD = 6,
+    /** The MIT/X11 standard license */
     MIT_X11 = 7,
+    /** The Artistic License, version 2.0 */
     ARTISTIC = 8,
+    /** The GNU General Public License, version 2.0 only */
     GPL_2_0_ONLY = 9,
+    /** The GNU General Public License, version 3.0 only */
     GPL_3_0_ONLY = 10,
+    /** The GNU Lesser General Public License, version 2.1 only */
     LGPL_2_1_ONLY = 11,
+    /** The GNU Lesser General Public License, version 3.0 only */
     LGPL_3_0_ONLY = 12,
+    /** The GNU Affero General Public License, version 3.0 or later */
     AGPL_3_0 = 13,
+    /** The GNU Affero General Public License, version 3.0 only */
     AGPL_3_0_ONLY = 14,
+    /** The 3-clause BSD licence */
     BSD_3 = 15,
+    /** The Apache License, version 2.0 */
     APACHE_2_0 = 16,
+    /** The Mozilla Public License, version 2.0 */
     MPL_2_0 = 17,
+    /** Zero-Clause BSD license */
     _0BSD = 18
 }
+/**
+ * Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
+ * and `GTK_DIR_TAB_BACKWARD` direction, like the `Tab` key
+ * in a [class@Gtk.ListView].
+ */
 export declare enum ListTabBehavior {
+    /** Cycle through all focusable items of the list */
     ALL = 0,
+    /**
+     * Cycle through a single list element, then move
+     * focus out of the list. Moving focus between items needs to be
+     * done with the arrow keys.
+     */
     ITEM = 1,
+    /**
+     * Cycle only through a single cell, then
+     * move focus out of the list. Moving focus between cells needs to
+     * be done with the arrow keys. This is only relevant for
+     * cell-based widgets like #GtkColumnView, otherwise it behaves
+     * like `GTK_LIST_TAB_ITEM`.
+     */
     CELL = 2
 }
+/** The type of message being displayed in a [class@MessageDialog]. */
 export declare enum MessageType {
+    /** Informational message */
     INFO = 0,
+    /** Non-fatal warning message */
     WARNING = 1,
+    /** Question requiring a choice */
     QUESTION = 2,
+    /** Fatal error message */
     ERROR = 3,
+    /** None of the above */
     OTHER = 4
 }
+/**
+ * Passed as argument to various keybinding signals for moving the
+ * cursor position.
+ */
 export declare enum MovementStep {
+    /** Move forward or back by graphemes */
     LOGICAL_POSITIONS = 0,
+    /** Move left or right by graphemes */
     VISUAL_POSITIONS = 1,
+    /** Move forward or back by words */
     WORDS = 2,
+    /** Move up or down lines (wrapped lines) */
     DISPLAY_LINES = 3,
+    /** Move to either end of a line */
     DISPLAY_LINE_ENDS = 4,
+    /** Move up or down paragraphs (newline-ended lines) */
     PARAGRAPHS = 5,
+    /** Move to either end of a paragraph */
     PARAGRAPH_ENDS = 6,
+    /** Move by pages */
     PAGES = 7,
+    /** Move to ends of the buffer */
     BUFFER_ENDS = 8,
+    /** Move horizontally by pages */
     HORIZONTAL_PAGES = 9
 }
+/**
+ * Options for selecting a different wrap mode for natural size
+ * requests.
+ *
+ * See for example the [property@Gtk.Label:natural-wrap-mode] property.
+ */
 export declare enum NaturalWrapMode {
+    /**
+     * Inherit the minimum size request.
+     * In particular, this should be used with %PANGO_WRAP_CHAR.
+     */
     INHERIT = 0,
+    /**
+     * Try not to wrap the text. This mode is the
+     * closest to GTK3's behavior but can lead to a wide label leaving
+     * lots of empty space below the text.
+     */
     NONE = 1,
+    /**
+     * Attempt to wrap at word boundaries. This
+     * is useful in particular when using %PANGO_WRAP_WORD_CHAR as the
+     * wrap mode.
+     */
     WORD = 2
 }
+/** The parameter used in the action signals of `GtkNotebook`. */
 export declare enum NotebookTab {
+    /** the first tab in the notebook */
     FIRST = 0,
+    /** the last tab in the notebook */
     LAST = 1
 }
+/**
+ * Used to determine the layout of pages on a sheet when printing
+ * multiple pages per sheet.
+ */
 export declare enum NumberUpLayout {
     LRTB = 0,
     LRBT = 1,
@@ -534,504 +1785,1445 @@ export declare enum NumberUpLayout {
     BTLR = 6,
     BTRL = 7
 }
+/**
+ * Describes the way two values can be compared.
+ *
+ * These values can be used with a [callback@GLib.CompareFunc]. However,
+ * a `GCompareFunc` is allowed to return any integer values.
+ * For converting such a value to a `GtkOrdering` value, use
+ * [func@Gtk.Ordering.from_cmpfunc].
+ */
 export declare enum Ordering {
+    /** the first value is smaller than the second */
     SMALLER = -1,
+    /** the two values are equal */
     EQUAL = 0,
+    /** the first value is larger than the second */
     LARGER = 1
 }
+/**
+ * Represents the orientation of widgets and other objects.
+ *
+ * Typical examples are [class@Box] or [class@GesturePan].
+ */
 export declare enum Orientation {
+    /** The element is in horizontal orientation. */
     HORIZONTAL = 0,
+    /** The element is in vertical orientation. */
     VERTICAL = 1
 }
+/**
+ * Defines how content overflowing a given area should be handled.
+ *
+ * This is used in [method@Gtk.Widget.set_overflow]. The
+ * [property@Gtk.Widget:overflow] property is modeled after the
+ * CSS overflow property, but implements it only partially.
+ */
 export declare enum Overflow {
+    /**
+     * No change is applied. Content is drawn at the specified
+     * position.
+     */
     VISIBLE = 0,
+    /**
+     * Content is clipped to the bounds of the area. Content
+     * outside the area is not drawn and cannot be interacted with.
+     */
     HIDDEN = 1
 }
+/**
+ * Represents the packing location of a children in its parent.
+ *
+ * See [class@WindowControls] for example.
+ */
 export declare enum PackType {
+    /** The child is packed into the start of the widget */
     START = 0,
+    /** The child is packed into the end of the widget */
     END = 1
 }
+/** The type of a pad action. */
 export declare enum PadActionType {
+    /** Action is triggered by a pad button */
     BUTTON = 0,
+    /** Action is triggered by a pad ring */
     RING = 1,
+    /** Action is triggered by a pad strip */
     STRIP = 2,
+    /** Action is triggered by a pad dial */
     DIAL = 3
 }
+/** See also gtk_print_settings_set_orientation(). */
 export declare enum PageOrientation {
+    /** Portrait mode. */
     PORTRAIT = 0,
+    /** Landscape mode. */
     LANDSCAPE = 1,
+    /** Reverse portrait mode. */
     REVERSE_PORTRAIT = 2,
+    /** Reverse landscape mode. */
     REVERSE_LANDSCAPE = 3
 }
+/** See also gtk_print_job_set_page_set(). */
 export declare enum PageSet {
+    /** All pages. */
     ALL = 0,
+    /** Even pages. */
     EVEN = 1,
+    /** Odd pages. */
     ODD = 2
 }
+/** Describes the panning direction of a [class@GesturePan]. */
 export declare enum PanDirection {
+    /** panned towards the left */
     LEFT = 0,
+    /** panned towards the right */
     RIGHT = 1,
+    /** panned upwards */
     UP = 2,
+    /** panned downwards */
     DOWN = 3
 }
+/**
+ * Determines how the size should be computed to achieve the one of the
+ * visibility mode for the scrollbars.
+ */
 export declare enum PolicyType {
+    /**
+     * The scrollbar is always visible. The view size is
+     * independent of the content.
+     */
     ALWAYS = 0,
+    /**
+     * The scrollbar will appear and disappear as necessary.
+     * For example, when all of a `GtkTreeView` can not be seen.
+     */
     AUTOMATIC = 1,
+    /**
+     * The scrollbar should never appear. In this mode the
+     * content determines the size.
+     */
     NEVER = 2,
+    /**
+     * Don't show a scrollbar, but don't force the
+     * size to follow the content. This can be used e.g. to make multiple
+     * scrolled windows share a scrollbar.
+     */
     EXTERNAL = 3
 }
+/**
+ * Describes which edge of a widget a certain feature is positioned at.
+ *
+ * For examples, see the tabs of a [class@Notebook], or the label
+ * of a [class@Scale].
+ */
 export declare enum PositionType {
+    /** The feature is at the left edge. */
     LEFT = 0,
+    /** The feature is at the right edge. */
     RIGHT = 1,
+    /** The feature is at the top edge. */
     TOP = 2,
+    /** The feature is at the bottom edge. */
     BOTTOM = 3
 }
+/** See also gtk_print_settings_set_duplex(). */
 export declare enum PrintDuplex {
+    /** No duplex. */
     SIMPLEX = 0,
+    /** Horizontal duplex. */
     HORIZONTAL = 1,
+    /** Vertical duplex. */
     VERTICAL = 2
 }
+/**
+ * Error codes that identify various errors that can occur while
+ * using the GTK printing support.
+ */
 export declare enum PrintError {
+    /** An unspecified error occurred. */
     GENERAL = 0,
+    /** An internal error occurred. */
     INTERNAL_ERROR = 1,
+    /** A memory allocation failed. */
     NOMEM = 2,
+    /**
+     * An error occurred while loading a page setup
+     * or paper size from a key file.
+     */
     INVALID_FILE = 3
 }
+/**
+ * Determines what action the print operation should perform.
+ *
+ * A parameter of this typs is passed to [method@Gtk.PrintOperation.run].
+ */
 export declare enum PrintOperationAction {
+    /** Show the print dialog. */
     PRINT_DIALOG = 0,
+    /**
+     * Start to print without showing
+     * the print dialog, based on the current print settings, if possible.
+     * Depending on the platform, a print dialog might appear anyway.
+     */
     PRINT = 1,
+    /** Show the print preview. */
     PREVIEW = 2,
+    /**
+     * Export to a file. This requires
+     * the export-filename property to be set.
+     */
     EXPORT = 3
 }
+/**
+ * The result of a print operation.
+ *
+ * A value of this type is returned by [method@Gtk.PrintOperation.run].
+ */
 export declare enum PrintOperationResult {
+    /** An error has occurred. */
     ERROR = 0,
+    /** The print settings should be stored. */
     APPLY = 1,
+    /**
+     * The print operation has been canceled,
+     * the print settings should not be stored.
+     */
     CANCEL = 2,
+    /**
+     * The print operation is not complete
+     * yet. This value will only be returned when running asynchronously.
+     */
     IN_PROGRESS = 3
 }
+/** See also gtk_print_job_set_pages() */
 export declare enum PrintPages {
+    /** All pages. */
     ALL = 0,
+    /** Current page. */
     CURRENT = 1,
+    /** Range of pages. */
     RANGES = 2,
+    /** Selected pages. */
     SELECTION = 3
 }
+/** See also gtk_print_settings_set_quality(). */
 export declare enum PrintQuality {
+    /** Low quality. */
     LOW = 0,
+    /** Normal quality. */
     NORMAL = 1,
+    /** High quality. */
     HIGH = 2,
+    /** Draft quality. */
     DRAFT = 3
 }
+/**
+ * The status gives a rough indication of the completion of a running
+ * print operation.
+ */
 export declare enum PrintStatus {
+    /**
+     * The printing has not started yet; this
+     * status is set initially, and while the print dialog is shown.
+     */
     INITIAL = 0,
+    /**
+     * This status is set while the begin-print
+     * signal is emitted and during pagination.
+     */
     PREPARING = 1,
+    /**
+     * This status is set while the
+     * pages are being rendered.
+     */
     GENERATING_DATA = 2,
+    /**
+     * The print job is being sent off to the
+     * printer.
+     */
     SENDING_DATA = 3,
+    /**
+     * The print job has been sent to the printer,
+     * but is not printed for some reason, e.g. the printer may be stopped.
+     */
     PENDING = 4,
+    /**
+     * Some problem has occurred during
+     * printing, e.g. a paper jam.
+     */
     PENDING_ISSUE = 5,
+    /** The printer is processing the print job. */
     PRINTING = 6,
+    /** The printing has been completed successfully. */
     FINISHED = 7,
+    /** The printing has been aborted. */
     FINISHED_ABORTED = 8
 }
+/**
+ * Describes limits of a [class@EventController] for handling events
+ * targeting other widgets.
+ */
 export declare enum PropagationLimit {
+    /**
+     * Events are handled regardless of what their
+     * target is.
+     */
     NONE = 0,
+    /**
+     * Events are only handled if their target is in
+     * the same [iface@Native] (or widget with [property@Gtk.Widget:limit-events]
+     * set) as the event controllers widget.
+     * Note that some event types have two targets (origin and destination).
+     */
     SAME_NATIVE = 1
 }
+/** Describes the stage at which events are fed into a [class@EventController]. */
 export declare enum PropagationPhase {
+    /** Events are not delivered. */
     NONE = 0,
+    /**
+     * Events are delivered in the capture phase. The
+     * capture phase happens before the bubble phase, runs from the toplevel down
+     * to the event widget. This option should only be used on containers that
+     * might possibly handle events before their children do.
+     */
     CAPTURE = 1,
+    /**
+     * Events are delivered in the bubble phase. The bubble
+     * phase happens after the capture phase, and before the default handlers
+     * are run. This phase runs from the event widget, up to the toplevel.
+     */
     BUBBLE = 2,
+    /**
+     * Events are delivered in the default widget event handlers,
+     * note that widget implementations must chain up on button, motion, touch and
+     * grab broken handlers for controllers in this phase to be run.
+     */
     TARGET = 3
 }
+/** Error codes for `GtkRecentManager` operations */
 export declare enum RecentManagerError {
+    /**
+     * the URI specified does not exists in
+     * the recently used resources list.
+     */
     NOT_FOUND = 0,
+    /** the URI specified is not valid. */
     INVALID_URI = 1,
+    /**
+     * the supplied string is not
+     * UTF-8 encoded.
+     */
     INVALID_ENCODING = 2,
+    /**
+     * no application has registered
+     * the specified item.
+     */
     NOT_REGISTERED = 3,
+    /**
+     * failure while reading the recently used
+     * resources file.
+     */
     READ = 4,
+    /**
+     * failure while writing the recently used
+     * resources file.
+     */
     WRITE = 5,
+    /** unspecified error. */
     UNKNOWN = 6
 }
+/**
+ * Predefined values for use as response ids in gtk_dialog_add_button().
+ *
+ * All predefined values are negative; GTK leaves values of 0 or greater for
+ * application-defined response ids.
+ */
 export declare enum ResponseType {
+    /**
+     * Returned if an action widget has no response id,
+     * or if the dialog gets programmatically hidden or destroyed
+     */
     NONE = -1,
+    /** Generic response id, not used by GTK dialogs */
     REJECT = -2,
+    /** Generic response id, not used by GTK dialogs */
     ACCEPT = -3,
+    /** Returned if the dialog is deleted */
     DELETE_EVENT = -4,
+    /** Returned by OK buttons in GTK dialogs */
     OK = -5,
+    /** Returned by Cancel buttons in GTK dialogs */
     CANCEL = -6,
+    /** Returned by Close buttons in GTK dialogs */
     CLOSE = -7,
+    /** Returned by Yes buttons in GTK dialogs */
     YES = -8,
+    /** Returned by No buttons in GTK dialogs */
     NO = -9,
+    /** Returned by Apply buttons in GTK dialogs */
     APPLY = -10,
+    /** Returned by Help buttons in GTK dialogs */
     HELP = -11
 }
+/**
+ * These enumeration values describe the possible transitions
+ * when the child of a `GtkRevealer` widget is shown or hidden.
+ */
 export declare enum RevealerTransitionType {
+    /** No transition */
     NONE = 0,
+    /** Fade in */
     CROSSFADE = 1,
+    /** Slide in from the left */
     SLIDE_RIGHT = 2,
+    /** Slide in from the right */
     SLIDE_LEFT = 3,
+    /** Slide in from the bottom */
     SLIDE_UP = 4,
+    /** Slide in from the top */
     SLIDE_DOWN = 5,
+    /** Floop in from the left */
     SWING_RIGHT = 6,
+    /** Floop in from the right */
     SWING_LEFT = 7,
+    /** Floop in from the bottom */
     SWING_UP = 8,
+    /** Floop in from the top */
     SWING_DOWN = 9
 }
+/** Passed as argument to various keybinding signals. */
 export declare enum ScrollStep {
+    /** Scroll in steps. */
     STEPS = 0,
+    /** Scroll by pages. */
     PAGES = 1,
+    /** Scroll to ends. */
     ENDS = 2,
+    /** Scroll in horizontal steps. */
     HORIZONTAL_STEPS = 3,
+    /** Scroll by horizontal pages. */
     HORIZONTAL_PAGES = 4,
+    /** Scroll to the horizontal ends. */
     HORIZONTAL_ENDS = 5
 }
+/** Scrolling types. */
 export declare enum ScrollType {
+    /** No scrolling. */
     NONE = 0,
+    /** Jump to new location. */
     JUMP = 1,
+    /** Step backward. */
     STEP_BACKWARD = 2,
+    /** Step forward. */
     STEP_FORWARD = 3,
+    /** Page backward. */
     PAGE_BACKWARD = 4,
+    /** Page forward. */
     PAGE_FORWARD = 5,
+    /** Step up. */
     STEP_UP = 6,
+    /** Step down. */
     STEP_DOWN = 7,
+    /** Page up. */
     PAGE_UP = 8,
+    /** Page down. */
     PAGE_DOWN = 9,
+    /** Step to the left. */
     STEP_LEFT = 10,
+    /** Step to the right. */
     STEP_RIGHT = 11,
+    /** Page to the left. */
     PAGE_LEFT = 12,
+    /** Page to the right. */
     PAGE_RIGHT = 13,
+    /** Scroll to start. */
     START = 14,
+    /** Scroll to end. */
     END = 15
 }
+/**
+ * Defines the policy to be used in a scrollable widget when updating
+ * the scrolled window adjustments in a given orientation.
+ */
 export declare enum ScrollablePolicy {
+    /** Scrollable adjustments are based on the minimum size */
     MINIMUM = 0,
+    /** Scrollable adjustments are based on the natural size */
     NATURAL = 1
 }
+/** Used to control what selections users are allowed to make. */
 export declare enum SelectionMode {
+    /** No selection is possible. */
     NONE = 0,
+    /** Zero or one element may be selected. */
     SINGLE = 1,
+    /**
+     * Exactly one element is selected.
+     * In some circumstances, such as initially or during a search
+     * operation, it’s possible for no element to be selected with
+     * %GTK_SELECTION_BROWSE. What is really enforced is that the user
+     * can’t deselect a currently selected element except by selecting
+     * another element.
+     */
     BROWSE = 2,
+    /**
+     * Any number of elements may be selected.
+     * The Ctrl key may be used to enlarge the selection, and Shift
+     * key to select between the focus and the child pointed to.
+     * Some widgets may also allow Click-drag to select a range of elements.
+     */
     MULTIPLE = 3
 }
+/**
+ * Determines how GTK handles the sensitivity of various controls,
+ * such as combo box buttons.
+ */
 export declare enum SensitivityType {
+    /**
+     * The control is made insensitive if no
+     * action can be triggered
+     */
     AUTO = 0,
+    /** The control is always sensitive */
     ON = 1,
+    /** The control is always insensitive */
     OFF = 2
 }
+/**
+ * Describes where [class@Shortcut]s added to a
+ * [class@ShortcutController] get handled.
+ */
 export declare enum ShortcutScope {
+    /**
+     * Shortcuts are handled inside
+     * the widget the controller belongs to.
+     */
     LOCAL = 0,
+    /**
+     * Shortcuts are handled by
+     * the first ancestor that is a [iface@ShortcutManager]
+     */
     MANAGED = 1,
+    /**
+     * Shortcuts are handled by
+     * the root widget.
+     */
     GLOBAL = 2
 }
+/**
+ * GtkShortcutType specifies the kind of shortcut that is being described.
+ *
+ * More values may be added to this enumeration over time.
+ */
 export declare enum ShortcutType {
+    /**
+     * The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator
+     * property will be used.
+     */
     ACCELERATOR = 0,
+    /** The shortcut is a pinch gesture. GTK provides an icon and subtitle. */
     GESTURE_PINCH = 1,
+    /** The shortcut is a stretch gesture. GTK provides an icon and subtitle. */
     GESTURE_STRETCH = 2,
+    /**
+     * The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
+     */
     GESTURE_ROTATE_CLOCKWISE = 3,
+    /**
+     * The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
+     */
     GESTURE_ROTATE_COUNTERCLOCKWISE = 4,
+    /** The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle. */
     GESTURE_TWO_FINGER_SWIPE_LEFT = 5,
+    /** The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle. */
     GESTURE_TWO_FINGER_SWIPE_RIGHT = 6,
+    /**
+     * The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be
+     * used.
+     */
     GESTURE = 7,
+    /** The shortcut is a swipe gesture. GTK provides an icon and subtitle. */
     GESTURE_SWIPE_LEFT = 8,
+    /** The shortcut is a swipe gesture. GTK provides an icon and subtitle. */
     GESTURE_SWIPE_RIGHT = 9
 }
+/**
+ * The mode of the size group determines the directions in which the size
+ * group affects the requested sizes of its component widgets.
+ */
 export declare enum SizeGroupMode {
+    /** group has no effect */
     NONE = 0,
+    /** group affects horizontal requisition */
     HORIZONTAL = 1,
+    /** group affects vertical requisition */
     VERTICAL = 2,
+    /** group affects both horizontal and vertical requisition */
     BOTH = 3
 }
+/**
+ * Specifies a preference for height-for-width or
+ * width-for-height geometry management.
+ */
 export declare enum SizeRequestMode {
+    /** Prefer height-for-width geometry management */
     HEIGHT_FOR_WIDTH = 0,
+    /** Prefer width-for-height geometry management */
     WIDTH_FOR_HEIGHT = 1,
+    /** Don’t trade height-for-width or width-for-height */
     CONSTANT_SIZE = 2
 }
+/** Determines the direction of a sort. */
 export declare enum SortType {
+    /** Sorting is in ascending order. */
     ASCENDING = 0,
+    /** Sorting is in descending order. */
     DESCENDING = 1
 }
+/**
+ * Describes changes in a sorter in more detail and allows users
+ * to optimize resorting.
+ */
 export declare enum SorterChange {
+    /**
+     * The sorter change cannot be described
+     * by any of the other enumeration values
+     */
     DIFFERENT = 0,
+    /**
+     * The sort order was inverted. Comparisons
+     * that returned %GTK_ORDERING_SMALLER now return %GTK_ORDERING_LARGER
+     * and vice versa. Other comparisons return the same values as before.
+     */
     INVERTED = 1,
+    /**
+     * The sorter is less strict: Comparisons
+     * may now return %GTK_ORDERING_EQUAL that did not do so before.
+     */
     LESS_STRICT = 2,
+    /**
+     * The sorter is more strict: Comparisons
+     * that did return %GTK_ORDERING_EQUAL may not do so anymore.
+     */
     MORE_STRICT = 3
 }
+/** Describes the type of order that a `GtkSorter` may produce. */
 export declare enum SorterOrder {
+    /** A partial order. Any `GtkOrdering` is possible. */
     PARTIAL = 0,
+    /**
+     * No order, all elements are considered equal.
+     * gtk_sorter_compare() will only return %GTK_ORDERING_EQUAL.
+     */
     NONE = 1,
+    /**
+     * A total order. gtk_sorter_compare() will only
+     * return %GTK_ORDERING_EQUAL if an item is compared with itself. Two
+     * different items will never cause this value to be returned.
+     */
     TOTAL = 2
 }
+/**
+ * Determines whether the spin button displays values outside the adjustment
+ * bounds.
+ *
+ * See [method@Gtk.SpinButton.set_update_policy].
+ */
 export declare enum SpinButtonUpdatePolicy {
+    /**
+     * When refreshing your `GtkSpinButton`, the value is
+     * always displayed
+     */
     ALWAYS = 0,
+    /**
+     * When refreshing your `GtkSpinButton`, the value is
+     * only displayed if it is valid within the bounds of the spin button's
+     * adjustment
+     */
     IF_VALID = 1
 }
+/**
+ * The values of the GtkSpinType enumeration are used to specify the
+ * change to make in gtk_spin_button_spin().
+ */
 export declare enum SpinType {
+    /** Increment by the adjustments step increment. */
     STEP_FORWARD = 0,
+    /** Decrement by the adjustments step increment. */
     STEP_BACKWARD = 1,
+    /** Increment by the adjustments page increment. */
     PAGE_FORWARD = 2,
+    /** Decrement by the adjustments page increment. */
     PAGE_BACKWARD = 3,
+    /** Go to the adjustments lower bound. */
     HOME = 4,
+    /** Go to the adjustments upper bound. */
     END = 5,
+    /** Change by a specified amount. */
     USER_DEFINED = 6
 }
+/**
+ * Possible transitions between pages in a `GtkStack` widget.
+ *
+ * New values may be added to this enumeration over time.
+ */
 export declare enum StackTransitionType {
+    /** No transition */
     NONE = 0,
+    /** A cross-fade */
     CROSSFADE = 1,
+    /** Slide from left to right */
     SLIDE_RIGHT = 2,
+    /** Slide from right to left */
     SLIDE_LEFT = 3,
+    /** Slide from bottom up */
     SLIDE_UP = 4,
+    /** Slide from top down */
     SLIDE_DOWN = 5,
+    /** Slide from left or right according to the children order */
     SLIDE_LEFT_RIGHT = 6,
+    /** Slide from top down or bottom up according to the order */
     SLIDE_UP_DOWN = 7,
+    /** Cover the old page by sliding up */
     OVER_UP = 8,
+    /** Cover the old page by sliding down */
     OVER_DOWN = 9,
+    /** Cover the old page by sliding to the left */
     OVER_LEFT = 10,
+    /** Cover the old page by sliding to the right */
     OVER_RIGHT = 11,
+    /** Uncover the new page by sliding up */
     UNDER_UP = 12,
+    /** Uncover the new page by sliding down */
     UNDER_DOWN = 13,
+    /** Uncover the new page by sliding to the left */
     UNDER_LEFT = 14,
+    /** Uncover the new page by sliding to the right */
     UNDER_RIGHT = 15,
+    /**
+     * Cover the old page sliding up or uncover the new page sliding down, according to order
+     */
     OVER_UP_DOWN = 16,
+    /**
+     * Cover the old page sliding down or uncover the new page sliding up, according to order
+     */
     OVER_DOWN_UP = 17,
+    /**
+     * Cover the old page sliding left or uncover the new page sliding right, according to order
+     */
     OVER_LEFT_RIGHT = 18,
+    /**
+     * Cover the old page sliding right or uncover the new page sliding left, according to order
+     */
     OVER_RIGHT_LEFT = 19,
+    /** Pretend the pages are sides of a cube and rotate that cube to the left */
     ROTATE_LEFT = 20,
+    /** Pretend the pages are sides of a cube and rotate that cube to the right */
     ROTATE_RIGHT = 21,
+    /**
+     * Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
+     */
     ROTATE_LEFT_RIGHT = 22
 }
+/** Specifies how search strings are matched inside text. */
 export declare enum StringFilterMatchMode {
+    /**
+     * The search string and
+     * text must match exactly
+     */
     EXACT = 0,
+    /**
+     * The search string
+     * must be contained as a substring inside the text
+     */
     SUBSTRING = 1,
+    /**
+     * The text must begin
+     * with the search string
+     */
     PREFIX = 2
 }
+/**
+ * The indexes of colors passed to symbolic color rendering, such as
+ * [vfunc@Gtk.SymbolicPaintable.snapshot_symbolic].
+ *
+ * More values may be added over time.
+ */
 export declare enum SymbolicColor {
+    /** The default foreground color */
     FOREGROUND = 0,
+    /** Indication color for errors */
     ERROR = 1,
+    /** Indication color for warnings */
     WARNING = 2,
+    /** Indication color for success */
     SUCCESS = 3
 }
+/**
+ * Values that can be passed to the [vfunc@Gtk.Widget.system_setting_changed]
+ * vfunc.
+ *
+ * The values indicate which system setting has changed.
+ * Widgets may need to drop caches, or react otherwise.
+ *
+ * Most of the values correspond to [class@Settings] properties.
+ *
+ * More values may be added over time.
+ */
 export declare enum SystemSetting {
+    /** the [property@Gtk.Settings:gtk-xft-dpi] setting has changed */
     DPI = 0,
+    /** The [property@Gtk.Settings:gtk-font-name] setting has changed */
     FONT_NAME = 1,
+    /**
+     * The font configuration has changed in a way that
+     * requires text to be redrawn. This can be any of the
+     * [property@Gtk.Settings:gtk-xft-antialias],
+     * [property@Gtk.Settings:gtk-xft-hinting],
+     * [property@Gtk.Settings:gtk-xft-hintstyle],
+     * [property@Gtk.Settings:gtk-xft-rgba] or
+     * [property@Gtk.Settings:gtk-fontconfig-timestamp] settings
+     */
     FONT_CONFIG = 2,
+    /** The display has changed */
     DISPLAY = 3,
+    /**
+     * The icon theme has changed in a way that requires
+     * icons to be looked up again
+     */
     ICON_THEME = 4
 }
+/** Reading directions for text. */
 export declare enum TextDirection {
+    /** No direction. */
     NONE = 0,
+    /** Left to right text direction. */
     LTR = 1,
+    /** Right to left text direction. */
     RTL = 2
 }
+/**
+ * Granularity types that extend the text selection. Use the
+ * `GtkTextView::extend-selection` signal to customize the selection.
+ */
 export declare enum TextExtendSelection {
+    /**
+     * Selects the current word. It is triggered by
+     * a double-click for example.
+     */
     WORD = 0,
+    /**
+     * Selects the current line. It is triggered by
+     * a triple-click for example.
+     */
     LINE = 1
 }
+/**
+ * Used to reference the layers of `GtkTextView` for the purpose of customized
+ * drawing with the ::snapshot_layer vfunc.
+ */
 export declare enum TextViewLayer {
+    /** The layer rendered below the text (but above the background). */
     BELOW_TEXT = 0,
+    /** The layer rendered above the text. */
     ABOVE_TEXT = 1
 }
+/** Used to reference the parts of `GtkTextView`. */
 export declare enum TextWindowType {
+    /** Window that floats over scrolling areas. */
     WIDGET = 1,
+    /** Scrollable text window. */
     TEXT = 2,
+    /** Left side border window. */
     LEFT = 3,
+    /** Right side border window. */
     RIGHT = 4,
+    /** Top border window. */
     TOP = 5,
+    /** Bottom border window. */
     BOTTOM = 6
 }
+/**
+ * The sizing method the column uses to determine its width.  Please note
+ * that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
+ * can make columns appear choppy.
+ */
 export declare enum TreeViewColumnSizing {
+    /** Columns only get bigger in reaction to changes in the model */
     GROW_ONLY = 0,
+    /** Columns resize to be the optimal size every time the model changes. */
     AUTOSIZE = 1,
+    /** Columns are a fixed numbers of pixels wide. */
     FIXED = 2
 }
+/** An enum for determining where a dropped row goes. */
 export declare enum TreeViewDropPosition {
+    /** dropped row is inserted before */
     BEFORE = 0,
+    /** dropped row is inserted after */
     AFTER = 1,
+    /** dropped row becomes a child or is inserted before */
     INTO_OR_BEFORE = 2,
+    /** dropped row becomes a child or is inserted after */
     INTO_OR_AFTER = 3
 }
+/** Used to indicate which grid lines to draw in a tree view. */
 export declare enum TreeViewGridLines {
+    /** No grid lines. */
     NONE = 0,
+    /** Horizontal grid lines. */
     HORIZONTAL = 1,
+    /** Vertical grid lines. */
     VERTICAL = 2,
+    /** Horizontal and vertical grid lines. */
     BOTH = 3
 }
+/** See also gtk_print_settings_set_paper_width(). */
 export declare enum Unit {
+    /** No units. */
     NONE = 0,
+    /** Dimensions in points. */
     POINTS = 1,
+    /** Dimensions in inches. */
     INCH = 2,
+    /** Dimensions in millimeters */
     MM = 3
 }
+/**
+ * Determines which point or edge of a window is meant to remain fixed
+ * when a window changes size.
+ */
 export declare enum WindowGravity {
+    /** The top left corner */
     TOP_LEFT = 0,
+    /** The top edge */
     TOP = 1,
+    /** The top right corner */
     TOP_RIGHT = 2,
+    /** The left edge */
     LEFT = 3,
+    /** The center pointer */
     CENTER = 4,
+    /** The right edge */
     RIGHT = 5,
+    /** The bottom left corner */
     BOTTOM_LEFT = 6,
+    /** the bottom edge */
     BOTTOM = 7,
+    /** The bottom right corner */
     BOTTOM_RIGHT = 8,
+    /**
+     * The top left or top right corner,
+     * depending on the text direction
+     */
     TOP_START = 9,
+    /**
+     * The top right or top left corner,
+     * depending on the text direction
+     */
     TOP_END = 10,
+    /**
+     * The left or right edge,
+     * depending on the text direction
+     */
     START = 11,
+    /**
+     * The right or left edge,
+     * depending on the text direction
+     */
     END = 12,
+    /**
+     * The bottom left or top right corner,
+     * depending on the text direction
+     */
     BOTTOM_START = 13,
+    /**
+     * The bottom right or top left corner,
+     * depending on the text direction
+     */
     BOTTOM_END = 14
 }
+/** Describes a type of line wrapping. */
 export declare enum WrapMode {
+    /** do not wrap lines; just make the text area wider */
     NONE = 0,
+    /**
+     * wrap text, breaking lines anywhere the cursor can
+     * appear (between characters, usually - if you want to be technical,
+     * between graphemes, see pango_get_log_attrs())
+     */
     CHAR = 1,
+    /** wrap text, breaking lines in between words */
     WORD = 2,
+    /**
+     * wrap text, breaking lines in between words, or if
+     * that is not enough, also between graphemes
+     */
     WORD_CHAR = 3
 }
+/**
+ * Types of user actions that may be blocked by `GtkApplication`.
+ *
+ * See [method@Gtk.Application.inhibit].
+ */
 export declare enum ApplicationInhibitFlags {
+    /**
+     * Inhibit ending the user session
+     * by logging out or by shutting down the computer
+     */
     LOGOUT = 1,
+    /** Inhibit user switching */
     SWITCH = 2,
+    /**
+     * Inhibit suspending the
+     * session or computer
+     */
     SUSPEND = 4,
+    /**
+     * Inhibit the session being
+     * marked as idle (and possibly locked)
+     */
     IDLE = 8
 }
+/**
+ * The list of flags that can be passed to gtk_builder_create_closure().
+ *
+ * New values may be added in the future for new features, so external
+ * implementations of [iface@Gtk.BuilderScope] should test the flags
+ * for unknown values and raise a %GTK_BUILDER_ERROR_INVALID_ATTRIBUTE error
+ * when they encounter one.
+ */
 export declare enum BuilderClosureFlags {
+    /**
+     * The closure should be created swapped. See
+     * g_cclosure_new_swap() for details.
+     */
     SWAPPED = 1
 }
+/** Tells how a cell is to be rendered. */
 export declare enum CellRendererState {
+    /**
+     * The cell is currently selected, and
+     * probably has a selection colored background to render to.
+     */
     SELECTED = 1,
+    /** The mouse is hovering over the cell. */
     PRELIT = 2,
+    /** The cell is drawn in an insensitive manner */
     INSENSITIVE = 4,
+    /** The cell is in a sorted row */
     SORTED = 8,
+    /** The cell is in the focus row. */
     FOCUSED = 16,
+    /** The cell is in a row that can be expanded */
     EXPANDABLE = 32,
+    /** The cell is in a row that is expanded */
     EXPANDED = 64
 }
+/**
+ * Flags to use with gtk_set_debug_flags().
+ *
+ * Settings these flags causes GTK to print out different
+ * types of debugging information. Some of these flags are
+ * only available when GTK has been configured with `-Ddebug=true`.
+ */
 export declare enum DebugFlags {
+    /** Information about GtkTextView */
     TEXT = 1,
+    /** Information about GtkTreeView */
     TREE = 2,
+    /** Information about keyboard shortcuts */
     KEYBINDINGS = 4,
+    /** Information about modules and extensions */
     MODULES = 8,
+    /** Information about size allocation */
     GEOMETRY = 16,
+    /** Information about icon themes */
     ICONTHEME = 32,
+    /** Information about printing */
     PRINTING = 64,
+    /** Trace GtkBuilder operation */
     BUILDER_TRACE = 128,
+    /** Information about size requests */
     SIZE_REQUEST = 256,
+    /** Disable the style property cache */
     NO_CSS_CACHE = 512,
+    /** Open the GTK inspector */
     INTERACTIVE = 1024,
+    /** Show touch UI elements for pointer events. */
     TOUCHSCREEN = 2048,
+    /** Information about actions and menu models */
     ACTIONS = 4096,
+    /** Information from layout managers */
     LAYOUT = 8192,
+    /** Include debug render nodes in the generated snapshots */
     SNAPSHOT = 16384,
+    /** Information from the constraints solver */
     CONSTRAINTS = 32768,
+    /** Log unused GtkBuilder objects */
     BUILDER_OBJECTS = 65536,
+    /** Information about accessibility state changes */
     A11Y = 131072,
+    /** Information about icon fallback. */
     ICONFALLBACK = 262144,
+    /** Inverts the default text-direction. */
     INVERT_TEXT_DIR = 524288,
+    /** Information about deprecated CSS features. */
     CSS = 1048576,
+    /** Information about deprecated GtkBuilder features. */
     BUILDER = 2097152
 }
+/** Flags used to influence dialog construction. */
 export declare enum DialogFlags {
+    /** Make the constructed dialog modal */
     MODAL = 1,
+    /** Destroy the dialog when its parent is destroyed */
     DESTROY_WITH_PARENT = 2,
+    /**
+     * Create dialog with actions in header
+     * bar instead of action area
+     */
     USE_HEADER_BAR = 4
 }
+/** Describes the behavior of a `GtkEventControllerScroll`. */
 export declare enum EventControllerScrollFlags {
+    /** Don't emit scroll. */
     NONE = 0,
+    /** Emit scroll with vertical deltas. */
     VERTICAL = 1,
+    /** Emit scroll with horizontal deltas. */
     HORIZONTAL = 2,
+    /** Only emit deltas that are multiples of 1. */
     DISCRETE = 4,
+    /** Emit ::decelerate after continuous scroll finishes. */
     KINETIC = 8,
+    /**
+     * A #GtkEventControllerScrollFlags value to prefer physical direction over
+     * logical direction (i.e. oblivious to natural scroll).
+     */
     PHYSICAL_DIRECTION = 16,
+    /** Emit scroll on both axes. */
     BOTH_AXES = 3
 }
+/**
+ * Specifies the granularity of font selection
+ * that is desired in a `GtkFontChooser`.
+ *
+ * This enumeration may be extended in the future; applications should
+ * ignore unknown values.
+ */
 export declare enum FontChooserLevel {
+    /** Allow selecting a font family */
     FAMILY = 0,
+    /** Allow selecting a specific font face */
     STYLE = 1,
+    /** Allow selecting a specific font size */
     SIZE = 2,
+    /** Allow changing OpenType font variation axes */
     VARIATIONS = 4,
+    /** Allow selecting specific OpenType font features */
     FEATURES = 8
 }
+/** Used to specify options for gtk_icon_theme_lookup_icon(). */
 export declare enum IconLookupFlags {
+    /** Perform a regular lookup. */
     NONE = 0,
+    /**
+     * Try to always load regular icons, even
+     * when symbolic icon names are given
+     */
     FORCE_REGULAR = 1,
+    /**
+     * Try to always load symbolic icons, even
+     * when regular icon names are given
+     */
     FORCE_SYMBOLIC = 2,
+    /**
+     * Starts loading the texture in the background
+     * so it is ready when later needed.
+     */
     PRELOAD = 4
 }
+/**
+ * Describes hints that might be taken into account by input methods
+ * or applications.
+ *
+ * Note that input methods may already tailor their behaviour according
+ * to the [enum@InputPurpose] of the entry.
+ *
+ * Some common sense is expected when using these flags - mixing
+ * %GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
+ *
+ * This enumeration may be extended in the future; input methods should
+ * ignore unknown values.
+ */
 export declare enum InputHints {
+    /** No special behaviour suggested */
     NONE = 0,
+    /** Suggest checking for typos */
     SPELLCHECK = 1,
+    /** Suggest not checking for typos */
     NO_SPELLCHECK = 2,
+    /** Suggest word completion */
     WORD_COMPLETION = 4,
+    /** Suggest to convert all text to lowercase */
     LOWERCASE = 8,
+    /** Suggest to capitalize all text */
     UPPERCASE_CHARS = 16,
+    /**
+     * Suggest to capitalize the first
+     * character of each word
+     */
     UPPERCASE_WORDS = 32,
+    /**
+     * Suggest to capitalize the
+     * first word of each sentence
+     */
     UPPERCASE_SENTENCES = 64,
+    /**
+     * Suggest to not show an onscreen keyboard
+     * (e.g for a calculator that already has all the keys).
+     */
     INHIBIT_OSK = 128,
+    /** The text is vertical */
     VERTICAL_WRITING = 256,
+    /** Suggest offering Emoji support */
     EMOJI = 512,
+    /** Suggest not offering Emoji support */
     NO_EMOJI = 1024,
+    /**
+     * Request that the input method should not
+     * update personalized data (like typing history)
+     */
     PRIVATE = 2048
 }
+/**
+ * List of actions to perform when scrolling to items in
+ * a list widget.
+ */
 export declare enum ListScrollFlags {
+    /** Don't do anything extra */
     NONE = 0,
+    /** Focus the target item */
     FOCUS = 1,
+    /**
+     * Select the target item and
+     * unselect all other items.
+     */
     SELECT = 2
 }
+/** Flags that influence the behavior of [method@Widget.pick]. */
 export declare enum PickFlags {
+    /** The default behavior, include widgets that are receiving events */
     DEFAULT = 0,
+    /** Include widgets that are insensitive */
     INSENSITIVE = 1,
+    /**
+     * Include widgets that are marked as non-targetable. See [property@Widget:can-target]
+     */
     NON_TARGETABLE = 2
 }
+/**
+ * Flags that affect how [class@Gtk.PopoverMenu] widgets built from
+ * a [class@Gio.MenuModel] are created and displayed.
+ */
 export declare enum PopoverMenuFlags {
+    /** Submenus are presented as sliding submenus that replace the main menu. */
     SLIDING = 0,
+    /**
+     * Submenus are presented as traditional, nested
+     * popovers.
+     */
     NESTED = 1
 }
+/**
+ * Specifies which features the print dialog should offer.
+ *
+ * If neither %GTK_PRINT_CAPABILITY_GENERATE_PDF nor
+ * %GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK assumes that all
+ * formats are supported.
+ */
 export declare enum PrintCapabilities {
+    /** Print dialog will offer printing even/odd pages. */
     PAGE_SET = 1,
+    /** Print dialog will allow to print multiple copies. */
     COPIES = 2,
+    /** Print dialog will allow to collate multiple copies. */
     COLLATE = 4,
+    /** Print dialog will allow to print pages in reverse order. */
     REVERSE = 8,
+    /** Print dialog will allow to scale the output. */
     SCALE = 16,
+    /**
+     * The program will send the document to
+     * the printer in PDF format
+     */
     GENERATE_PDF = 32,
+    /**
+     * The program will send the document to
+     * the printer in Postscript format
+     */
     GENERATE_PS = 64,
+    /** Print dialog will offer a preview */
     PREVIEW = 128,
+    /**
+     * Print dialog will offer printing multiple
+     * pages per sheet
+     */
     NUMBER_UP = 256,
+    /**
+     * Print dialog will allow to rearrange
+     * pages when printing multiple pages per sheet
+     */
     NUMBER_UP_LAYOUT = 512
 }
+/**
+ * Flags that can be passed to action activation.
+ *
+ * More flags may be added in the future.
+ */
 export declare enum ShortcutActionFlags {
+    /**
+     * The action is the only
+     * action that can be activated. If this flag is not set,
+     * a future activation may select a different action.
+     */
     EXCLUSIVE = 1
 }
+/**
+ * Describes a widget state.
+ *
+ * Widget states are used to match the widget against CSS pseudo-classes.
+ * Note that GTK extends the regular CSS classes and sometimes uses
+ * different names.
+ */
 export declare enum StateFlags {
+    /** State during normal operation */
     NORMAL = 0,
+    /** Widget is active */
     ACTIVE = 1,
+    /** Widget has a mouse pointer over it */
     PRELIGHT = 2,
+    /** Widget is selected */
     SELECTED = 4,
+    /** Widget is insensitive */
     INSENSITIVE = 8,
+    /** Widget is inconsistent */
     INCONSISTENT = 16,
+    /** Widget has the keyboard focus */
     FOCUSED = 32,
+    /** Widget is in a background toplevel window */
     BACKDROP = 64,
+    /** Widget is in left-to-right text direction */
     DIR_LTR = 128,
+    /** Widget is in right-to-left text direction */
     DIR_RTL = 256,
+    /** Widget is a link */
     LINK = 512,
+    /** The location the widget points to has already been visited */
     VISITED = 1024,
+    /** Widget is checked */
     CHECKED = 2048,
+    /** Widget is highlighted as a drop target for DND */
     DROP_ACTIVE = 4096,
+    /** Widget has the visible focus */
     FOCUS_VISIBLE = 8192,
+    /** Widget contains the keyboard focus */
     FOCUS_WITHIN = 16384
 }
+/**
+ * Flags that modify the behavior of gtk_style_context_to_string().
+ *
+ * New values may be added to this enumeration.
+ */
 export declare enum StyleContextPrintFlags {
+    /** Default value. */
     NONE = 0,
+    /**
+     * Print the entire tree of
+     * CSS nodes starting at the style context's node
+     */
     RECURSE = 1,
+    /**
+     * Show the values of the
+     * CSS properties for each node
+     */
     SHOW_STYLE = 2,
+    /**
+     * Show information about
+     * what changes affect the styles
+     */
     SHOW_CHANGE = 4
 }
+/**
+ * Values for [callback@Gtk.TextBufferCommitNotify] to denote the
+ * point of the notification.
+ */
 export declare enum TextBufferNotifyFlags {
+    /**
+     * Be notified before text
+     * is inserted into the underlying buffer.
+     */
     BEFORE_INSERT = 1,
+    /**
+     * Be notified after text
+     * has been inserted into the underlying buffer.
+     */
     AFTER_INSERT = 2,
+    /**
+     * Be notified before text
+     * is deleted from the underlying buffer.
+     */
     BEFORE_DELETE = 4,
+    /**
+     * Be notified after text
+     * has been deleted from the underlying buffer.
+     */
     AFTER_DELETE = 8
 }
+/**
+ * Flags affecting how a search is done.
+ *
+ * If neither `GTK_TEXT_SEARCH_VISIBLE_ONLY` nor `GTK_TEXT_SEARCH_TEXT_ONLY`
+ * are enabled, the match must be exact; the special 0xFFFC character will
+ * match embedded paintables or child widgets.
+ */
 export declare enum TextSearchFlags {
+    /**
+     * Search only visible data. A search match may
+     * have invisible text interspersed.
+     */
     VISIBLE_ONLY = 1,
+    /**
+     * Search only text. A match may have paintables or
+     * child widgets mixed inside the matched range.
+     */
     TEXT_ONLY = 2,
+    /**
+     * The text will be matched regardless of
+     * what case it is in.
+     */
     CASE_INSENSITIVE = 4
 }
+/**
+ * These flags indicate various properties of a `GtkTreeModel`.
+ *
+ * They are returned by [method@Gtk.TreeModel.get_flags], and must be
+ * static for the lifetime of the object. A more complete description
+ * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
+ * this section.
+ */
 export declare enum TreeModelFlags {
+    /**
+     * iterators survive all signals
+     * emitted by the tree
+     */
     ITERS_PERSIST = 1,
+    /**
+     * the model is a list only, and never
+     * has children
+     */
     LIST_ONLY = 2
 }