@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/enums.js

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