@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gdk/enums.js

@@ -1,393 +1,1462 @@
+/**
+ * Defines how device axes are interpreted by GTK.
+ *
+ * Note that the X and Y axes are not really needed; pointer devices
+ * report their location via the x/y members of events regardless. Whether
+ * X and Y are present as axes depends on the GDK backend.
+ */
 export var AxisUse;
 (function (AxisUse) {
+    /** the axis is ignored. */
     AxisUse[AxisUse["IGNORE"] = 0] = "IGNORE";
+    /** the axis is used as the x axis. */
     AxisUse[AxisUse["X"] = 1] = "X";
+    /** the axis is used as the y axis. */
     AxisUse[AxisUse["Y"] = 2] = "Y";
+    /** the axis is used as the scroll x delta */
     AxisUse[AxisUse["DELTA_X"] = 3] = "DELTA_X";
+    /** the axis is used as the scroll y delta */
     AxisUse[AxisUse["DELTA_Y"] = 4] = "DELTA_Y";
+    /** the axis is used for pressure information. */
     AxisUse[AxisUse["PRESSURE"] = 5] = "PRESSURE";
+    /** the axis is used for x tilt information. */
     AxisUse[AxisUse["XTILT"] = 6] = "XTILT";
+    /** the axis is used for y tilt information. */
     AxisUse[AxisUse["YTILT"] = 7] = "YTILT";
+    /** the axis is used for wheel information. */
     AxisUse[AxisUse["WHEEL"] = 8] = "WHEEL";
+    /** the axis is used for pen/tablet distance information */
     AxisUse[AxisUse["DISTANCE"] = 9] = "DISTANCE";
+    /** the axis is used for pen rotation information */
     AxisUse[AxisUse["ROTATION"] = 10] = "ROTATION";
+    /** the axis is used for pen slider information */
     AxisUse[AxisUse["SLIDER"] = 11] = "SLIDER";
+    /** a constant equal to the numerically highest axis value. */
     AxisUse[AxisUse["LAST"] = 12] = "LAST";
 })(AxisUse || (AxisUse = {}));
+/**
+ * The values of this enumeration describe whether image data uses
+ * the full range of 8-bit values.
+ *
+ * In digital broadcasting, it is common to reserve the lowest and
+ * highest values. Typically the allowed values for the narrow range
+ * are 16-235 for Y and 16-240 for u,v (when dealing with YUV data).
+ */
 export var CicpRange;
 (function (CicpRange) {
+    /** The values use the range of 16-235 (for Y) and 16-240 for u and v. */
     CicpRange[CicpRange["NARROW"] = 0] = "NARROW";
+    /** The values use the full range. */
     CicpRange[CicpRange["FULL"] = 1] = "FULL";
 })(CicpRange || (CicpRange = {}));
+/** Specifies the crossing mode for enter and leave events. */
 export var CrossingMode;
 (function (CrossingMode) {
+    /** crossing because of pointer motion. */
     CrossingMode[CrossingMode["NORMAL"] = 0] = "NORMAL";
+    /** crossing because a grab is activated. */
     CrossingMode[CrossingMode["GRAB"] = 1] = "GRAB";
+    /** crossing because a grab is deactivated. */
     CrossingMode[CrossingMode["UNGRAB"] = 2] = "UNGRAB";
+    /** crossing because a GTK grab is activated. */
     CrossingMode[CrossingMode["GTK_GRAB"] = 3] = "GTK_GRAB";
+    /** crossing because a GTK grab is deactivated. */
     CrossingMode[CrossingMode["GTK_UNGRAB"] = 4] = "GTK_UNGRAB";
+    /**
+     * crossing because a GTK widget changed
+     * state (e.g. sensitivity).
+     */
     CrossingMode[CrossingMode["STATE_CHANGED"] = 5] = "STATE_CHANGED";
+    /**
+     * crossing because a touch sequence has begun,
+     * this event is synthetic as the pointer might have not left the surface.
+     */
     CrossingMode[CrossingMode["TOUCH_BEGIN"] = 6] = "TOUCH_BEGIN";
+    /**
+     * crossing because a touch sequence has ended,
+     * this event is synthetic as the pointer might have not left the surface.
+     */
     CrossingMode[CrossingMode["TOUCH_END"] = 7] = "TOUCH_END";
+    /**
+     * crossing because of a device switch (i.e.
+     * a mouse taking control of the pointer after a touch device), this event
+     * is synthetic as the pointer didn’t leave the surface.
+     */
     CrossingMode[CrossingMode["DEVICE_SWITCH"] = 8] = "DEVICE_SWITCH";
 })(CrossingMode || (CrossingMode = {}));
+/** A pad feature. */
 export var DevicePadFeature;
 (function (DevicePadFeature) {
+    /** a button */
     DevicePadFeature[DevicePadFeature["BUTTON"] = 0] = "BUTTON";
+    /** a ring-shaped interactive area */
     DevicePadFeature[DevicePadFeature["RING"] = 1] = "RING";
+    /** a straight interactive area */
     DevicePadFeature[DevicePadFeature["STRIP"] = 2] = "STRIP";
 })(DevicePadFeature || (DevicePadFeature = {}));
+/**
+ * Indicates the specific type of tool being used being a tablet. Such as an
+ * airbrush, pencil, etc.
+ */
 export var DeviceToolType;
 (function (DeviceToolType) {
+    /** Tool is of an unknown type. */
     DeviceToolType[DeviceToolType["UNKNOWN"] = 0] = "UNKNOWN";
+    /** Tool is a standard tablet stylus. */
     DeviceToolType[DeviceToolType["PEN"] = 1] = "PEN";
+    /** Tool is standard tablet eraser. */
     DeviceToolType[DeviceToolType["ERASER"] = 2] = "ERASER";
+    /** Tool is a brush stylus. */
     DeviceToolType[DeviceToolType["BRUSH"] = 3] = "BRUSH";
+    /** Tool is a pencil stylus. */
     DeviceToolType[DeviceToolType["PENCIL"] = 4] = "PENCIL";
+    /** Tool is an airbrush stylus. */
     DeviceToolType[DeviceToolType["AIRBRUSH"] = 5] = "AIRBRUSH";
+    /** Tool is a mouse. */
     DeviceToolType[DeviceToolType["MOUSE"] = 6] = "MOUSE";
+    /** Tool is a lens cursor. */
     DeviceToolType[DeviceToolType["LENS"] = 7] = "LENS";
 })(DeviceToolType || (DeviceToolType = {}));
+/** Error enumeration for `GdkDmabufTexture`. */
 export var DmabufError;
 (function (DmabufError) {
+    /**
+     * Dmabuf support is not available, because the OS
+     * is not Linux, or it was explicitly disabled at compile- or runtime
+     */
     DmabufError[DmabufError["NOT_AVAILABLE"] = 0] = "NOT_AVAILABLE";
+    /** The requested format is not supported */
     DmabufError[DmabufError["UNSUPPORTED_FORMAT"] = 1] = "UNSUPPORTED_FORMAT";
+    /**
+     * GTK failed to create the resource for other
+     * reasons
+     */
     DmabufError[DmabufError["CREATION_FAILED"] = 2] = "CREATION_FAILED";
 })(DmabufError || (DmabufError = {}));
+/** Used in `GdkDrag` to the reason of a cancelled DND operation. */
 export var DragCancelReason;
 (function (DragCancelReason) {
+    /** There is no suitable drop target. */
     DragCancelReason[DragCancelReason["NO_TARGET"] = 0] = "NO_TARGET";
+    /** Drag cancelled by the user */
     DragCancelReason[DragCancelReason["USER_CANCELLED"] = 1] = "USER_CANCELLED";
+    /** Unspecified error. */
     DragCancelReason[DragCancelReason["ERROR"] = 2] = "ERROR";
 })(DragCancelReason || (DragCancelReason = {}));
+/** Specifies the type of the event. */
 export var EventType;
 (function (EventType) {
+    /**
+     * the window manager has requested that the toplevel surface be
+     * hidden or destroyed, usually when the user clicks on a special icon in the
+     * title bar.
+     */
     EventType[EventType["DELETE"] = 0] = "DELETE";
+    /** the pointer (usually a mouse) has moved. */
     EventType[EventType["MOTION_NOTIFY"] = 1] = "MOTION_NOTIFY";
+    /** a mouse button has been pressed. */
     EventType[EventType["BUTTON_PRESS"] = 2] = "BUTTON_PRESS";
+    /** a mouse button has been released. */
     EventType[EventType["BUTTON_RELEASE"] = 3] = "BUTTON_RELEASE";
+    /** a key has been pressed. */
     EventType[EventType["KEY_PRESS"] = 4] = "KEY_PRESS";
+    /** a key has been released. */
     EventType[EventType["KEY_RELEASE"] = 5] = "KEY_RELEASE";
+    /** the pointer has entered the surface. */
     EventType[EventType["ENTER_NOTIFY"] = 6] = "ENTER_NOTIFY";
+    /** the pointer has left the surface. */
     EventType[EventType["LEAVE_NOTIFY"] = 7] = "LEAVE_NOTIFY";
+    /** the keyboard focus has entered or left the surface. */
     EventType[EventType["FOCUS_CHANGE"] = 8] = "FOCUS_CHANGE";
+    /**
+     * an input device has moved into contact with a sensing
+     * surface (e.g. a touchscreen or graphics tablet).
+     */
     EventType[EventType["PROXIMITY_IN"] = 9] = "PROXIMITY_IN";
+    /**
+     * an input device has moved out of contact with a sensing
+     * surface.
+     */
     EventType[EventType["PROXIMITY_OUT"] = 10] = "PROXIMITY_OUT";
+    /** the mouse has entered the surface while a drag is in progress. */
     EventType[EventType["DRAG_ENTER"] = 11] = "DRAG_ENTER";
+    /** the mouse has left the surface while a drag is in progress. */
     EventType[EventType["DRAG_LEAVE"] = 12] = "DRAG_LEAVE";
+    /**
+     * the mouse has moved in the surface while a drag is in
+     * progress.
+     */
     EventType[EventType["DRAG_MOTION"] = 13] = "DRAG_MOTION";
+    /** a drop operation onto the surface has started. */
     EventType[EventType["DROP_START"] = 14] = "DROP_START";
+    /** the scroll wheel was turned */
     EventType[EventType["SCROLL"] = 15] = "SCROLL";
+    /** a pointer or keyboard grab was broken. */
     EventType[EventType["GRAB_BROKEN"] = 16] = "GRAB_BROKEN";
+    /** A new touch event sequence has just started. */
     EventType[EventType["TOUCH_BEGIN"] = 17] = "TOUCH_BEGIN";
+    /** A touch event sequence has been updated. */
     EventType[EventType["TOUCH_UPDATE"] = 18] = "TOUCH_UPDATE";
+    /** A touch event sequence has finished. */
     EventType[EventType["TOUCH_END"] = 19] = "TOUCH_END";
+    /** A touch event sequence has been canceled. */
     EventType[EventType["TOUCH_CANCEL"] = 20] = "TOUCH_CANCEL";
+    /**
+     * A touchpad swipe gesture event, the current state
+     * is determined by its phase field.
+     */
     EventType[EventType["TOUCHPAD_SWIPE"] = 21] = "TOUCHPAD_SWIPE";
+    /**
+     * A touchpad pinch gesture event, the current state
+     * is determined by its phase field.
+     */
     EventType[EventType["TOUCHPAD_PINCH"] = 22] = "TOUCHPAD_PINCH";
+    /** A tablet pad button press event. */
     EventType[EventType["PAD_BUTTON_PRESS"] = 23] = "PAD_BUTTON_PRESS";
+    /** A tablet pad button release event. */
     EventType[EventType["PAD_BUTTON_RELEASE"] = 24] = "PAD_BUTTON_RELEASE";
+    /** A tablet pad axis event from a "ring". */
     EventType[EventType["PAD_RING"] = 25] = "PAD_RING";
+    /** A tablet pad axis event from a "strip". */
     EventType[EventType["PAD_STRIP"] = 26] = "PAD_STRIP";
+    /** A tablet pad group mode change. */
     EventType[EventType["PAD_GROUP_MODE"] = 27] = "PAD_GROUP_MODE";
+    /**
+     * A touchpad hold gesture event, the current state is determined by its phase
+     * field.
+     */
     EventType[EventType["TOUCHPAD_HOLD"] = 28] = "TOUCHPAD_HOLD";
+    /** A tablet pad axis event from a "dial". */
     EventType[EventType["PAD_DIAL"] = 29] = "PAD_DIAL";
+    /** marks the end of the GdkEventType enumeration. */
     EventType[EventType["EVENT_LAST"] = 30] = "EVENT_LAST";
 })(EventType || (EventType = {}));
+/** Indicates which monitor a surface should span over when in fullscreen mode. */
 export var FullscreenMode;
 (function (FullscreenMode) {
+    /** Fullscreen on current monitor only. */
     FullscreenMode[FullscreenMode["CURRENT_MONITOR"] = 0] = "CURRENT_MONITOR";
+    /** Span across all monitors when fullscreen. */
     FullscreenMode[FullscreenMode["ALL_MONITORS"] = 1] = "ALL_MONITORS";
 })(FullscreenMode || (FullscreenMode = {}));
+/** Error enumeration for `GdkGLContext`. */
 export var GLError;
 (function (GLError) {
+    /** OpenGL support is not available */
     GLError[GLError["NOT_AVAILABLE"] = 0] = "NOT_AVAILABLE";
+    /** The requested visual format is not supported */
     GLError[GLError["UNSUPPORTED_FORMAT"] = 1] = "UNSUPPORTED_FORMAT";
+    /** The requested profile is not supported */
     GLError[GLError["UNSUPPORTED_PROFILE"] = 2] = "UNSUPPORTED_PROFILE";
+    /** The shader compilation failed */
     GLError[GLError["COMPILATION_FAILED"] = 3] = "COMPILATION_FAILED";
+    /** The shader linking failed */
     GLError[GLError["LINK_FAILED"] = 4] = "LINK_FAILED";
 })(GLError || (GLError = {}));
+/** Defines the reference point of a surface and is used in `GdkPopupLayout`. */
 export var Gravity;
 (function (Gravity) {
+    /** the reference point is at the top left corner. */
     Gravity[Gravity["NORTH_WEST"] = 1] = "NORTH_WEST";
+    /** the reference point is in the middle of the top edge. */
     Gravity[Gravity["NORTH"] = 2] = "NORTH";
+    /** the reference point is at the top right corner. */
     Gravity[Gravity["NORTH_EAST"] = 3] = "NORTH_EAST";
+    /** the reference point is at the middle of the left edge. */
     Gravity[Gravity["WEST"] = 4] = "WEST";
+    /** the reference point is at the center of the surface. */
     Gravity[Gravity["CENTER"] = 5] = "CENTER";
+    /** the reference point is at the middle of the right edge. */
     Gravity[Gravity["EAST"] = 6] = "EAST";
+    /** the reference point is at the lower left corner. */
     Gravity[Gravity["SOUTH_WEST"] = 7] = "SOUTH_WEST";
+    /** the reference point is at the middle of the lower edge. */
     Gravity[Gravity["SOUTH"] = 8] = "SOUTH";
+    /** the reference point is at the lower right corner. */
     Gravity[Gravity["SOUTH_EAST"] = 9] = "SOUTH_EAST";
+    /**
+     * the reference point is at the top left corner of the
+     * surface itself, ignoring window manager decorations.
+     */
     Gravity[Gravity["STATIC"] = 10] = "STATIC";
 })(Gravity || (Gravity = {}));
+/** An enumeration describing the type of an input device in general terms. */
 export var InputSource;
 (function (InputSource) {
+    /**
+     * the device is a mouse. (This will be reported for the core
+     * pointer, even if it is something else, such as a trackball.)
+     */
     InputSource[InputSource["MOUSE"] = 0] = "MOUSE";
+    /** the device is a stylus of a graphics tablet or similar device. */
     InputSource[InputSource["PEN"] = 1] = "PEN";
+    /** the device is a keyboard. */
     InputSource[InputSource["KEYBOARD"] = 2] = "KEYBOARD";
+    /**
+     * the device is a direct-input touch device, such
+     * as a touchscreen or tablet
+     */
     InputSource[InputSource["TOUCHSCREEN"] = 3] = "TOUCHSCREEN";
+    /**
+     * the device is an indirect touch device, such
+     * as a touchpad
+     */
     InputSource[InputSource["TOUCHPAD"] = 4] = "TOUCHPAD";
+    /** the device is a trackpoint */
     InputSource[InputSource["TRACKPOINT"] = 5] = "TRACKPOINT";
+    /**
+     * the device is a "pad", a collection of buttons,
+     * rings and strips found in drawing tablets
+     */
     InputSource[InputSource["TABLET_PAD"] = 6] = "TABLET_PAD";
 })(InputSource || (InputSource = {}));
+/**
+ * Describes how well an event matches a given keyval and modifiers.
+ *
+ * `GdkKeyMatch` values are returned by [method@Gdk.KeyEvent.matches].
+ */
 export var KeyMatch;
 (function (KeyMatch) {
+    /** The key event does not match */
     KeyMatch[KeyMatch["NONE"] = 0] = "NONE";
+    /**
+     * The key event matches if keyboard state
+     * (specifically, the currently active group) is ignored
+     */
     KeyMatch[KeyMatch["PARTIAL"] = 1] = "PARTIAL";
+    /** The key event matches */
     KeyMatch[KeyMatch["EXACT"] = 2] = "EXACT";
 })(KeyMatch || (KeyMatch = {}));
+/**
+ * Describes formats that image data can have in memory.
+ *
+ * It describes formats by listing the contents of the memory passed to it.
+ * So `GDK_MEMORY_A8R8G8B8` will be 1 byte (8 bits) of alpha, followed by a
+ * byte each of red, green and blue. It is not endian-dependent, so
+ * `CAIRO_FORMAT_ARGB32` is represented by different `GdkMemoryFormats`
+ * on architectures with different endiannesses.
+ *
+ * Its naming is modelled after
+ * VkFormat
+ * for details).
+ */
 export var MemoryFormat;
 (function (MemoryFormat) {
+    /**
+     * 4 bytes; for blue, green, red, alpha.
+     * The color values are premultiplied with the alpha value.
+     */
     MemoryFormat[MemoryFormat["B8G8R8A8_PREMULTIPLIED"] = 0] = "B8G8R8A8_PREMULTIPLIED";
+    /**
+     * 4 bytes; for alpha, red, green, blue.
+     * The color values are premultiplied with the alpha value.
+     */
     MemoryFormat[MemoryFormat["A8R8G8B8_PREMULTIPLIED"] = 1] = "A8R8G8B8_PREMULTIPLIED";
+    /**
+     * 4 bytes; for red, green, blue, alpha
+     * The color values are premultiplied with the alpha value.
+     */
     MemoryFormat[MemoryFormat["R8G8B8A8_PREMULTIPLIED"] = 2] = "R8G8B8A8_PREMULTIPLIED";
+    /** 4 bytes; for blue, green, red, alpha. */
     MemoryFormat[MemoryFormat["B8G8R8A8"] = 3] = "B8G8R8A8";
+    /** 4 bytes; for alpha, red, green, blue. */
     MemoryFormat[MemoryFormat["A8R8G8B8"] = 4] = "A8R8G8B8";
+    /** 4 bytes; for red, green, blue, alpha. */
     MemoryFormat[MemoryFormat["R8G8B8A8"] = 5] = "R8G8B8A8";
+    /** 4 bytes; for alpha, blue, green, red. */
     MemoryFormat[MemoryFormat["A8B8G8R8"] = 6] = "A8B8G8R8";
+    /** 3 bytes; for red, green, blue. The data is opaque. */
     MemoryFormat[MemoryFormat["R8G8B8"] = 7] = "R8G8B8";
+    /** 3 bytes; for blue, green, red. The data is opaque. */
     MemoryFormat[MemoryFormat["B8G8R8"] = 8] = "B8G8R8";
+    /** 3 guint16 values; for red, green, blue. */
     MemoryFormat[MemoryFormat["R16G16B16"] = 9] = "R16G16B16";
+    /**
+     * 4 guint16 values; for red, green, blue, alpha. The color values are
+     * premultiplied with the alpha value.
+     */
     MemoryFormat[MemoryFormat["R16G16B16A16_PREMULTIPLIED"] = 10] = "R16G16B16A16_PREMULTIPLIED";
+    /** 4 guint16 values; for red, green, blue, alpha. */
     MemoryFormat[MemoryFormat["R16G16B16A16"] = 11] = "R16G16B16A16";
+    /** 3 half-float values; for red, green, blue. The data is opaque. */
     MemoryFormat[MemoryFormat["R16G16B16_FLOAT"] = 12] = "R16G16B16_FLOAT";
+    /**
+     * 4 half-float values; for red, green, blue and alpha. The color values are
+     * premultiplied with the alpha value.
+     */
     MemoryFormat[MemoryFormat["R16G16B16A16_FLOAT_PREMULTIPLIED"] = 13] = "R16G16B16A16_FLOAT_PREMULTIPLIED";
+    /** 4 half-float values; for red, green, blue and alpha. */
     MemoryFormat[MemoryFormat["R16G16B16A16_FLOAT"] = 14] = "R16G16B16A16_FLOAT";
+    /** 3 float values; for red, green, blue. */
     MemoryFormat[MemoryFormat["R32G32B32_FLOAT"] = 15] = "R32G32B32_FLOAT";
+    /**
+     * 4 float values; for red, green, blue and alpha. The color values are
+     * premultiplied with the alpha value.
+     */
     MemoryFormat[MemoryFormat["R32G32B32A32_FLOAT_PREMULTIPLIED"] = 16] = "R32G32B32A32_FLOAT_PREMULTIPLIED";
+    /** 4 float values; for red, green, blue and alpha. */
     MemoryFormat[MemoryFormat["R32G32B32A32_FLOAT"] = 17] = "R32G32B32A32_FLOAT";
+    /**
+     * 2 bytes; for grayscale, alpha. The color values are premultiplied with the
+     * alpha value.
+     */
     MemoryFormat[MemoryFormat["G8A8_PREMULTIPLIED"] = 18] = "G8A8_PREMULTIPLIED";
+    /** 2 bytes; for grayscale, alpha. */
     MemoryFormat[MemoryFormat["G8A8"] = 19] = "G8A8";
+    /** One byte; for grayscale. The data is opaque. */
     MemoryFormat[MemoryFormat["G8"] = 20] = "G8";
+    /**
+     * 2 guint16 values; for grayscale, alpha. The color values are premultiplied
+     * with the alpha value.
+     */
     MemoryFormat[MemoryFormat["G16A16_PREMULTIPLIED"] = 21] = "G16A16_PREMULTIPLIED";
+    /** 2 guint16 values; for grayscale, alpha. */
     MemoryFormat[MemoryFormat["G16A16"] = 22] = "G16A16";
+    /** One guint16 value; for grayscale. The data is opaque. */
     MemoryFormat[MemoryFormat["G16"] = 23] = "G16";
+    /** One byte; for alpha. */
     MemoryFormat[MemoryFormat["A8"] = 24] = "A8";
+    /** One guint16 value; for alpha. */
     MemoryFormat[MemoryFormat["A16"] = 25] = "A16";
+    /** One half-float value; for alpha. */
     MemoryFormat[MemoryFormat["A16_FLOAT"] = 26] = "A16_FLOAT";
+    /** One float value; for alpha. */
     MemoryFormat[MemoryFormat["A32_FLOAT"] = 27] = "A32_FLOAT";
+    /**
+     * 4 bytes; for alpha, blue, green, red, The color values are premultiplied with
+     * the alpha value.
+     */
     MemoryFormat[MemoryFormat["A8B8G8R8_PREMULTIPLIED"] = 28] = "A8B8G8R8_PREMULTIPLIED";
+    /** 4 bytes; for blue, green, red, unused. */
     MemoryFormat[MemoryFormat["B8G8R8X8"] = 29] = "B8G8R8X8";
+    /** 4 bytes; for unused, red, green, blue. */
     MemoryFormat[MemoryFormat["X8R8G8B8"] = 30] = "X8R8G8B8";
+    /** 4 bytes; for red, green, blue, unused. */
     MemoryFormat[MemoryFormat["R8G8B8X8"] = 31] = "R8G8B8X8";
+    /** 4 bytes; for unused, blue, green, red. */
     MemoryFormat[MemoryFormat["X8B8G8R8"] = 32] = "X8B8G8R8";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cb followed by Cr.
+     * Subsampled in both the X and Y direction.
+     *
+     * Commonly known by the fourcc "NV12".
+     */
     MemoryFormat[MemoryFormat["G8_B8R8_420"] = 33] = "G8_B8R8_420";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cr followed by Cb.
+     * Subsampled in both the X and Y direction.
+     *
+     * Commonly known by the fourcc "NV21".
+     */
     MemoryFormat[MemoryFormat["G8_R8B8_420"] = 34] = "G8_R8B8_420";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cb followed by Cr.
+     * Subsampled in the X direction.
+     *
+     * Commonly known by the fourcc "NV16".
+     */
     MemoryFormat[MemoryFormat["G8_B8R8_422"] = 35] = "G8_B8R8_422";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cr followed by Cb.
+     * Subsampled in the X direction.
+     *
+     * Commonly known by the fourcc "NV61".
+     */
     MemoryFormat[MemoryFormat["G8_R8B8_422"] = 36] = "G8_R8B8_422";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cb followed by Cr.
+     * This format is not subsampled.
+     *
+     * Commonly known by the fourcc "NV24".
+     */
     MemoryFormat[MemoryFormat["G8_B8R8_444"] = 37] = "G8_B8R8_444";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cr followed by Cb.
+     * This format is not subsampled.
+     *
+     * Commonly known by the fourcc "NV42".
+     */
     MemoryFormat[MemoryFormat["G8_R8B8_444"] = 38] = "G8_R8B8_444";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * Each channel is a 16 bit integer, but only the highest 10 bits are used.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cr followed by Cb.
+     * This format is not subsampled.
+     *
+     * Commonly known by the fourcc "P010".
+     */
     MemoryFormat[MemoryFormat["G10X6_B10X6R10X6_420"] = 39] = "G10X6_B10X6R10X6_420";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * Each channel is a 16 bit integer, but only the highest 10 bits are used.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cr followed by Cb.
+     * This format is not subsampled.
+     *
+     * Commonly known by the fourcc "P012".
+     */
     MemoryFormat[MemoryFormat["G12X4_B12X4R12X4_420"] = 40] = "G12X4_B12X4R12X4_420";
+    /**
+     * Multiplane format with 2 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * The first plane contains the first channel, usually containing
+     * luma values.
+     * The second plane with interleaved chroma values, Cr followed by Cb.
+     * This format is not subsampled.
+     *
+     * Commonly known by the fourcc "P016".
+     */
     MemoryFormat[MemoryFormat["G16_B16R16_420"] = 41] = "G16_B16R16_420";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in both the X and Y direction with 4:1 ratio. It is
+     * mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in both the X and Y direction with 4:1 ratio. It is
+     * mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "YUV410".
+     */
     MemoryFormat[MemoryFormat["G8_B8_R8_410"] = 42] = "G8_B8_R8_410";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the second chroma chanel.
+     * Subsampled in both the X and Y direction with 4:1 ratio. It is
+     * mapped into the 1st channel.
+     *
+     * The third plane usually contains the first chroma channel.
+     * Subsampled in both the X and Y direction with 4:1 ratio. It is
+     * mapped into the 3rd channel.
+     *
+     * Commonly known by the fourcc "YVU410".
+     */
     MemoryFormat[MemoryFormat["G8_R8_B8_410"] = 43] = "G8_R8_B8_410";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in the X direction with 4:1 ratio. It is
+     * mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in the X direction with 4:1 ratio. It is
+     * mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "YUV411".
+     */
     MemoryFormat[MemoryFormat["G8_B8_R8_411"] = 44] = "G8_B8_R8_411";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the second chroma chanel.
+     * Subsampled in the X direction with 4:1 ratio. It is
+     * mapped into the 1st channel.
+     *
+     * The third plane usually contains the first chroma channel.
+     * Subsampled in the X direction with 4:1 ratio. It is
+     * mapped into the 3rd channel.
+     *
+     * Commonly known by the fourcc "YVU411".
+     */
     MemoryFormat[MemoryFormat["G8_R8_B8_411"] = 45] = "G8_R8_B8_411";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 1st channel.
+     *
+     * Commonly known by the fourcc "YUV420".
+     */
     MemoryFormat[MemoryFormat["G8_B8_R8_420"] = 46] = "G8_B8_R8_420";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the second chroma chanel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 1st channel.
+     *
+     * The third plane usually contains the first chroma channel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 3rd channel.
+     *
+     * Commonly known by the fourcc "YVU420".
+     */
     MemoryFormat[MemoryFormat["G8_R8_B8_420"] = 47] = "G8_R8_B8_420";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in the X direction. It is mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in the X direction. It is mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "YUV422".
+     */
     MemoryFormat[MemoryFormat["G8_B8_R8_422"] = 48] = "G8_B8_R8_422";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the second chroma chanel.
+     * Subsampled in the X direction. It is mapped into the 1st channel.
+     *
+     * The third plane usually contains the first chroma channel.
+     * Subsampled in the X direction. It is mapped into the 3rd channel.
+     *
+     * Commonly known by the fourcc "YVU422".
+     */
     MemoryFormat[MemoryFormat["G8_R8_B8_422"] = 49] = "G8_R8_B8_422";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel. It is
+     * mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel. It is
+     * mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "YUV444".
+     */
     MemoryFormat[MemoryFormat["G8_B8_R8_444"] = 50] = "G8_B8_R8_444";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 8 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the second chroma chanel.
+     * Subsampled in the X direction. It is mapped into the 1st channel.
+     *
+     * The third plane usually contains the first chroma channel.
+     * Subsampled in the X direction. It is mapped into the 3rd channel.
+     *
+     * Commonly known by the fourcc "YVU444".
+     */
     MemoryFormat[MemoryFormat["G8_R8_B8_444"] = 51] = "G8_R8_B8_444";
+    /**
+     * Packed format with subsampled channels.
+     *
+     * Each channel is a 8 bit integer. The red and blue/chroma channels
+     * are subsampled and interleaved with the green/luma channel.
+     *
+     * Each block contains 2 pixels, so the width must be a multiple of
+     * 2.
+     *
+     * Commonly known by the fourcc "YUYV".
+     */
     MemoryFormat[MemoryFormat["G8B8G8R8_422"] = 52] = "G8B8G8R8_422";
+    /**
+     * Packed format with subsampled channels.
+     *
+     * Each channel is a 8 bit integer. The red and blue/chroma channels
+     * are subsampled and interleaved with the green/luma channel.
+     *
+     * Each block contains 2 pixels, so the width must be a multiple of
+     * 2.
+     *
+     * Commonly known by the fourcc "YVYU".
+     */
     MemoryFormat[MemoryFormat["G8R8G8B8_422"] = 53] = "G8R8G8B8_422";
+    /**
+     * Packed format with subsampled channels.
+     *
+     * Each channel is a 8 bit integer. The red and blue/chroma channels
+     * are subsampled and interleaved with the green/luma channel.
+     *
+     * Each block contains 2 pixels, so the width must be a multiple of
+     * 2.
+     *
+     * Commonly known by the fourcc "VYUY".
+     */
     MemoryFormat[MemoryFormat["R8G8B8G8_422"] = 54] = "R8G8B8G8_422";
+    /**
+     * Packed format with subsampled channels.
+     *
+     * Each channel is a 8 bit integer. The red and blue/chroma channels
+     * are subsampled and interleaved with the green/luma channel.
+     *
+     * Each block contains 2 pixels, so the width must be a multiple of
+     * 2.
+     *
+     * Commonly known by the fourcc "UYVY".
+     */
     MemoryFormat[MemoryFormat["B8G8R8G8_422"] = 55] = "B8G8R8G8_422";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * Only the 10 lower bits are used. The remaining ones must be set to 0 by the
+     * producer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 1st channel.
+     *
+     * Commonly known by the fourcc "S010".
+     */
     MemoryFormat[MemoryFormat["X6G10_X6B10_X6R10_420"] = 56] = "X6G10_X6B10_X6R10_420";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * Only the 10 lower bits are used. The remaining ones must be set to 0 by the
+     * producer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in the X direction. It is mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in the X direction. It is mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "S210".
+     */
     MemoryFormat[MemoryFormat["X6G10_X6B10_X6R10_422"] = 57] = "X6G10_X6B10_X6R10_422";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * Only the 10 lower bits are used. The remaining ones must be set to 0 by the
+     * producer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel. It is
+     * mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel. It is
+     * mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "S410".
+     */
     MemoryFormat[MemoryFormat["X6G10_X6B10_X6R10_444"] = 58] = "X6G10_X6B10_X6R10_444";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * Only the 12 lower bits are used. The remaining ones must be set to 0 by the
+     * producer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 1st channel.
+     *
+     * Commonly known by the fourcc "S012".
+     */
     MemoryFormat[MemoryFormat["X4G12_X4B12_X4R12_420"] = 59] = "X4G12_X4B12_X4R12_420";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * Only the 12 lower bits are used. The remaining ones must be set to 0 by the
+     * producer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in the X direction. It is mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in the X direction. It is mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "S212".
+     */
     MemoryFormat[MemoryFormat["X4G12_X4B12_X4R12_422"] = 60] = "X4G12_X4B12_X4R12_422";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * Only the 12 lower bits are used. The remaining ones must be set to 0 by the
+     * producer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel. It is
+     * mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel. It is
+     * mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "S412".
+     */
     MemoryFormat[MemoryFormat["X4G12_X4B12_X4R12_444"] = 61] = "X4G12_X4B12_X4R12_444";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in both the X and Y direction. It is mapped into the
+     * 1st channel.
+     *
+     * Commonly known by the fourcc "S016".
+     */
     MemoryFormat[MemoryFormat["G16_B16_R16_420"] = 62] = "G16_B16_R16_420";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel.
+     * Subsampled in the X direction. It is mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel.
+     * Subsampled in the X direction. It is mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "S216".
+     */
     MemoryFormat[MemoryFormat["G16_B16_R16_422"] = 63] = "G16_B16_R16_422";
+    /**
+     * Multiplane format with 3 planes.
+     *
+     * Each channel is a 16 bit integer.
+     *
+     * The first plane usually contains the luma channel. It is mapped
+     * into the 2nd channel.
+     *
+     * The second plane usually contains the first chroma chanel. It is
+     * mapped into the 3rd channel.
+     *
+     * The third plane usually contains the second chroma channel. It is
+     * mapped into the 1st channel.
+     *
+     * Commonly known by the fourcc "S416".
+     */
     MemoryFormat[MemoryFormat["G16_B16_R16_444"] = 64] = "G16_B16_R16_444";
+    /**
+     * The number of formats. This value will change as
+     * more formats get added, so do not rely on its concrete integer.
+     */
     MemoryFormat[MemoryFormat["N_FORMATS"] = 65] = "N_FORMATS";
 })(MemoryFormat || (MemoryFormat = {}));
+/**
+ * Specifies the kind of crossing for enter and leave events.
+ *
+ * See the X11 protocol specification of LeaveNotify for
+ * full details of crossing event generation.
+ */
 export var NotifyType;
 (function (NotifyType) {
+    /**
+     * the surface is entered from an ancestor or
+     * left towards an ancestor.
+     */
     NotifyType[NotifyType["ANCESTOR"] = 0] = "ANCESTOR";
+    /**
+     * the pointer moves between an ancestor and an
+     * inferior of the surface.
+     */
     NotifyType[NotifyType["VIRTUAL"] = 1] = "VIRTUAL";
+    /**
+     * the surface is entered from an inferior or
+     * left towards an inferior.
+     */
     NotifyType[NotifyType["INFERIOR"] = 2] = "INFERIOR";
+    /**
+     * the surface is entered from or left towards
+     * a surface which is neither an ancestor nor an inferior.
+     */
     NotifyType[NotifyType["NONLINEAR"] = 3] = "NONLINEAR";
+    /**
+     * the pointer moves between two surfaces
+     * which are not ancestors of each other and the surface is part of
+     * the ancestor chain between one of these surfaces and their least
+     * common ancestor.
+     */
     NotifyType[NotifyType["NONLINEAR_VIRTUAL"] = 4] = "NONLINEAR_VIRTUAL";
+    /** an unknown type of enter/leave event occurred. */
     NotifyType[NotifyType["UNKNOWN"] = 5] = "UNKNOWN";
 })(NotifyType || (NotifyType = {}));
+/** Specifies the direction for scroll events. */
 export var ScrollDirection;
 (function (ScrollDirection) {
+    /** the surface is scrolled up. */
     ScrollDirection[ScrollDirection["UP"] = 0] = "UP";
+    /** the surface is scrolled down. */
     ScrollDirection[ScrollDirection["DOWN"] = 1] = "DOWN";
+    /** the surface is scrolled to the left. */
     ScrollDirection[ScrollDirection["LEFT"] = 2] = "LEFT";
+    /** the surface is scrolled to the right. */
     ScrollDirection[ScrollDirection["RIGHT"] = 3] = "RIGHT";
+    /**
+     * the scrolling is determined by the delta values
+     * in scroll events. See gdk_scroll_event_get_deltas()
+     */
     ScrollDirection[ScrollDirection["SMOOTH"] = 4] = "SMOOTH";
 })(ScrollDirection || (ScrollDirection = {}));
+/**
+ * Used in scroll events, to announce the direction relative
+ * to physical motion.
+ */
 export var ScrollRelativeDirection;
 (function (ScrollRelativeDirection) {
+    /** Physical motion and event motion are the same */
     ScrollRelativeDirection[ScrollRelativeDirection["IDENTICAL"] = 0] = "IDENTICAL";
+    /** Physical motion is inverted relative to event motion */
     ScrollRelativeDirection[ScrollRelativeDirection["INVERTED"] = 1] = "INVERTED";
+    /** Relative motion is unknown on this device or backend */
     ScrollRelativeDirection[ScrollRelativeDirection["UNKNOWN"] = 2] = "UNKNOWN";
 })(ScrollRelativeDirection || (ScrollRelativeDirection = {}));
+/**
+ * Specifies the unit of scroll deltas.
+ *
+ * When you get %GDK_SCROLL_UNIT_WHEEL, a delta of 1.0 means 1 wheel detent
+ * click in the south direction, 2.0 means 2 wheel detent clicks in the south
+ * direction... This is the same logic for negative values but in the north
+ * direction.
+ *
+ * If you get %GDK_SCROLL_UNIT_SURFACE, are managing a scrollable view and get a
+ * value of 123, you have to scroll 123 surface logical pixels right if it's
+ * `delta_x` or down if it's @delta_y. This is the same logic for negative values
+ * but you have to scroll left instead of right if it's `delta_x` and up instead
+ * of down if it's @delta_y.
+ *
+ * 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
+ * final scale factor of your graphical interface (the product of the desktop
+ * scale factor and eventually a custom scale factor in your app).
+ */
 export var ScrollUnit;
 (function (ScrollUnit) {
+    /** The delta is in number of wheel clicks. */
     ScrollUnit[ScrollUnit["WHEEL"] = 0] = "WHEEL";
+    /**
+     * The delta is in surface pixels to scroll directly
+     * on screen.
+     */
     ScrollUnit[ScrollUnit["SURFACE"] = 1] = "SURFACE";
 })(ScrollUnit || (ScrollUnit = {}));
+/**
+ * This enumeration describes how the red, green and blue components
+ * of physical pixels on an output device are laid out.
+ */
 export var SubpixelLayout;
 (function (SubpixelLayout) {
+    /** The layout is not known */
     SubpixelLayout[SubpixelLayout["UNKNOWN"] = 0] = "UNKNOWN";
+    /** Not organized in this way */
     SubpixelLayout[SubpixelLayout["NONE"] = 1] = "NONE";
+    /** The layout is horizontal, the order is RGB */
     SubpixelLayout[SubpixelLayout["HORIZONTAL_RGB"] = 2] = "HORIZONTAL_RGB";
+    /** The layout is horizontal, the order is BGR */
     SubpixelLayout[SubpixelLayout["HORIZONTAL_BGR"] = 3] = "HORIZONTAL_BGR";
+    /** The layout is vertical, the order is RGB */
     SubpixelLayout[SubpixelLayout["VERTICAL_RGB"] = 4] = "VERTICAL_RGB";
+    /** The layout is vertical, the order is BGR */
     SubpixelLayout[SubpixelLayout["VERTICAL_BGR"] = 5] = "VERTICAL_BGR";
 })(SubpixelLayout || (SubpixelLayout = {}));
+/** Determines a surface edge or corner. */
 export var SurfaceEdge;
 (function (SurfaceEdge) {
+    /** the top left corner. */
     SurfaceEdge[SurfaceEdge["NORTH_WEST"] = 0] = "NORTH_WEST";
+    /** the top edge. */
     SurfaceEdge[SurfaceEdge["NORTH"] = 1] = "NORTH";
+    /** the top right corner. */
     SurfaceEdge[SurfaceEdge["NORTH_EAST"] = 2] = "NORTH_EAST";
+    /** the left edge. */
     SurfaceEdge[SurfaceEdge["WEST"] = 3] = "WEST";
+    /** the right edge. */
     SurfaceEdge[SurfaceEdge["EAST"] = 4] = "EAST";
+    /** the lower left corner. */
     SurfaceEdge[SurfaceEdge["SOUTH_WEST"] = 5] = "SOUTH_WEST";
+    /** the lower edge. */
     SurfaceEdge[SurfaceEdge["SOUTH"] = 6] = "SOUTH";
+    /** the lower right corner. */
     SurfaceEdge[SurfaceEdge["SOUTH_EAST"] = 7] = "SOUTH_EAST";
 })(SurfaceEdge || (SurfaceEdge = {}));
+/** Possible errors that can be returned by `GdkTexture` constructors. */
 export var TextureError;
 (function (TextureError) {
+    /** Not enough memory to handle this image */
     TextureError[TextureError["TOO_LARGE"] = 0] = "TOO_LARGE";
+    /** The image data appears corrupted */
     TextureError[TextureError["CORRUPT_IMAGE"] = 1] = "CORRUPT_IMAGE";
+    /**
+     * The image contains features
+     * that cannot be loaded
+     */
     TextureError[TextureError["UNSUPPORTED_CONTENT"] = 2] = "UNSUPPORTED_CONTENT";
+    /** The image format is not supported */
     TextureError[TextureError["UNSUPPORTED_FORMAT"] = 3] = "UNSUPPORTED_FORMAT";
 })(TextureError || (TextureError = {}));
+/**
+ * The kind of title bar gesture to emit with
+ * [method@Gdk.Toplevel.titlebar_gesture].
+ */
 export var TitlebarGesture;
 (function (TitlebarGesture) {
+    /** double click gesture */
     TitlebarGesture[TitlebarGesture["DOUBLE_CLICK"] = 1] = "DOUBLE_CLICK";
+    /** right click gesture */
     TitlebarGesture[TitlebarGesture["RIGHT_CLICK"] = 2] = "RIGHT_CLICK";
+    /** middle click gesture */
     TitlebarGesture[TitlebarGesture["MIDDLE_CLICK"] = 3] = "MIDDLE_CLICK";
 })(TitlebarGesture || (TitlebarGesture = {}));
+/**
+ * Specifies the current state of a touchpad gesture.
+ *
+ * All gestures are guaranteed to begin with an event with phase
+ * %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events
+ * with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
+ *
+ * A finished gesture may have 2 possible outcomes, an event with phase
+ * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
+ * considered successful, this should be used as the hint to perform any
+ * permanent changes.
+ *
+ * Cancelled gestures may be so for a variety of reasons, due to hardware
+ * or the compositor, or due to the gesture recognition layers hinting the
+ * gesture did not finish resolutely (eg. a 3rd finger being added during
+ * a pinch gesture). In these cases, the last event will report the phase
+ * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
+ * to undo any visible/permanent changes that were done throughout the
+ * progress of the gesture.
+ */
 export var TouchpadGesturePhase;
 (function (TouchpadGesturePhase) {
+    /** The gesture has begun. */
     TouchpadGesturePhase[TouchpadGesturePhase["BEGIN"] = 0] = "BEGIN";
+    /** The gesture has been updated. */
     TouchpadGesturePhase[TouchpadGesturePhase["UPDATE"] = 1] = "UPDATE";
+    /**
+     * The gesture was finished, changes
+     * should be permanently applied.
+     */
     TouchpadGesturePhase[TouchpadGesturePhase["END"] = 2] = "END";
+    /**
+     * The gesture was cancelled, all
+     * changes should be undone.
+     */
     TouchpadGesturePhase[TouchpadGesturePhase["CANCEL"] = 3] = "CANCEL";
 })(TouchpadGesturePhase || (TouchpadGesturePhase = {}));
+/** Error enumeration for `GdkVulkanContext`. */
 export var VulkanError;
 (function (VulkanError) {
+    /**
+     * Vulkan is not supported on this backend or has not been
+     * compiled in.
+     */
     VulkanError[VulkanError["UNSUPPORTED"] = 0] = "UNSUPPORTED";
+    /** Vulkan support is not available on this Surface */
     VulkanError[VulkanError["NOT_AVAILABLE"] = 1] = "NOT_AVAILABLE";
 })(VulkanError || (VulkanError = {}));
+/**
+ * Positioning hints for aligning a surface relative to a rectangle.
+ *
+ * These hints determine how the surface should be positioned in the case that
+ * the surface would fall off-screen if placed in its ideal position.
+ *
+ * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
+ * %GDK_GRAVITY_NORTH_EAST and vice versa if the surface extends beyond the left
+ * or right edges of the monitor.
+ *
+ * If %GDK_ANCHOR_SLIDE_X is set, the surface can be shifted horizontally to fit
+ * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the surface can be shrunken
+ * horizontally to fit.
+ *
+ * In general, when multiple flags are set, flipping should take precedence over
+ * sliding, which should take precedence over resizing.
+ */
 export var AnchorHints;
 (function (AnchorHints) {
+    /** allow flipping anchors horizontally */
     AnchorHints[AnchorHints["FLIP_X"] = 1] = "FLIP_X";
+    /** allow flipping anchors vertically */
     AnchorHints[AnchorHints["FLIP_Y"] = 2] = "FLIP_Y";
+    /** allow sliding surface horizontally */
     AnchorHints[AnchorHints["SLIDE_X"] = 4] = "SLIDE_X";
+    /** allow sliding surface vertically */
     AnchorHints[AnchorHints["SLIDE_Y"] = 8] = "SLIDE_Y";
+    /** allow resizing surface horizontally */
     AnchorHints[AnchorHints["RESIZE_X"] = 16] = "RESIZE_X";
+    /** allow resizing surface vertically */
     AnchorHints[AnchorHints["RESIZE_Y"] = 32] = "RESIZE_Y";
+    /** allow flipping anchors on both axes */
     AnchorHints[AnchorHints["FLIP"] = 3] = "FLIP";
+    /** allow sliding surface on both axes */
     AnchorHints[AnchorHints["SLIDE"] = 12] = "SLIDE";
+    /** allow resizing surface on both axes */
     AnchorHints[AnchorHints["RESIZE"] = 48] = "RESIZE";
 })(AnchorHints || (AnchorHints = {}));
+/** Flags describing the current capabilities of a device/tool. */
 export var AxisFlags;
 (function (AxisFlags) {
+    /** X axis is present */
     AxisFlags[AxisFlags["X"] = 2] = "X";
+    /** Y axis is present */
     AxisFlags[AxisFlags["Y"] = 4] = "Y";
+    /** Scroll X delta axis is present */
     AxisFlags[AxisFlags["DELTA_X"] = 8] = "DELTA_X";
+    /** Scroll Y delta axis is present */
     AxisFlags[AxisFlags["DELTA_Y"] = 16] = "DELTA_Y";
+    /** Pressure axis is present */
     AxisFlags[AxisFlags["PRESSURE"] = 32] = "PRESSURE";
+    /** X tilt axis is present */
     AxisFlags[AxisFlags["XTILT"] = 64] = "XTILT";
+    /** Y tilt axis is present */
     AxisFlags[AxisFlags["YTILT"] = 128] = "YTILT";
+    /** Wheel axis is present */
     AxisFlags[AxisFlags["WHEEL"] = 256] = "WHEEL";
+    /** Distance axis is present */
     AxisFlags[AxisFlags["DISTANCE"] = 512] = "DISTANCE";
+    /** Z-axis rotation is present */
     AxisFlags[AxisFlags["ROTATION"] = 1024] = "ROTATION";
+    /** Slider axis is present */
     AxisFlags[AxisFlags["SLIDER"] = 2048] = "SLIDER";
 })(AxisFlags || (AxisFlags = {}));
+/**
+ * Used in `GdkDrop` and `GdkDrag` to indicate the actions that the
+ * destination can and should do with the dropped data.
+ */
 export var DragAction;
 (function (DragAction) {
+    /** No action. */
     DragAction[DragAction["NONE"] = 0] = "NONE";
+    /** Copy the data. */
     DragAction[DragAction["COPY"] = 1] = "COPY";
+    /**
+     * Move the data, i.e. first copy it, then delete
+     * it from the source using the DELETE target of the X selection protocol.
+     */
     DragAction[DragAction["MOVE"] = 2] = "MOVE";
+    /**
+     * Add a link to the data. Note that this is only
+     * useful if source and destination agree on what it means, and is not
+     * supported on all platforms.
+     */
     DragAction[DragAction["LINK"] = 4] = "LINK";
+    /** Ask the user what to do with the data. */
     DragAction[DragAction["ASK"] = 8] = "ASK";
 })(DragAction || (DragAction = {}));
+/**
+ * Used to represent the different paint clock phases that can be requested.
+ *
+ * The elements of the enumeration correspond to the signals of `GdkFrameClock`.
+ */
 export var FrameClockPhase;
 (function (FrameClockPhase) {
+    /** no phase */
     FrameClockPhase[FrameClockPhase["NONE"] = 0] = "NONE";
+    /**
+     * corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
+     */
     FrameClockPhase[FrameClockPhase["FLUSH_EVENTS"] = 1] = "FLUSH_EVENTS";
+    /**
+     * corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
+     */
     FrameClockPhase[FrameClockPhase["BEFORE_PAINT"] = 2] = "BEFORE_PAINT";
+    /** corresponds to GdkFrameClock::update. */
     FrameClockPhase[FrameClockPhase["UPDATE"] = 4] = "UPDATE";
+    /** corresponds to GdkFrameClock::layout. Should not be handled by applications. */
     FrameClockPhase[FrameClockPhase["LAYOUT"] = 8] = "LAYOUT";
+    /** corresponds to GdkFrameClock::paint. */
     FrameClockPhase[FrameClockPhase["PAINT"] = 16] = "PAINT";
+    /**
+     * corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
+     */
     FrameClockPhase[FrameClockPhase["RESUME_EVENTS"] = 32] = "RESUME_EVENTS";
+    /**
+     * corresponds to GdkFrameClock::after-paint. Should not be handled by applications.
+     */
     FrameClockPhase[FrameClockPhase["AFTER_PAINT"] = 64] = "AFTER_PAINT";
 })(FrameClockPhase || (FrameClockPhase = {}));
+/** The list of the different APIs that GdkGLContext can potentially support. */
 export var GLAPI;
 (function (GLAPI) {
+    /** The OpenGL API */
     GLAPI[GLAPI["GL"] = 1] = "GL";
+    /** The OpenGL ES API */
     GLAPI[GLAPI["GLES"] = 2] = "GLES";
 })(GLAPI || (GLAPI = {}));
+/**
+ * Flags to indicate the state of modifier keys and mouse buttons
+ * in events.
+ *
+ * Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose,
+ * Apple, CapsLock or ShiftLock.
+ *
+ * Note that GDK may add internal values to events which include values outside
+ * of this enumeration. Your code should preserve and ignore them. You can use
+ * %GDK_MODIFIER_MASK to remove all private values.
+ */
 export var ModifierType;
 (function (ModifierType) {
+    /** No modifier. */
     ModifierType[ModifierType["NO_MODIFIER_MASK"] = 0] = "NO_MODIFIER_MASK";
+    /** the Shift key. */
     ModifierType[ModifierType["SHIFT_MASK"] = 1] = "SHIFT_MASK";
+    /**
+     * a Lock key (depending on the Windowing System configuration,
+     * this may either be `CapsLock` or `ShiftLock`).
+     */
     ModifierType[ModifierType["LOCK_MASK"] = 2] = "LOCK_MASK";
+    /** the Control key. */
     ModifierType[ModifierType["CONTROL_MASK"] = 4] = "CONTROL_MASK";
+    /**
+     * the fourth modifier key (it depends on the Windowing System
+     * configuration which key is interpreted as this modifier, but normally it
+     * is the `Alt` key).
+     */
     ModifierType[ModifierType["ALT_MASK"] = 8] = "ALT_MASK";
+    /** the first mouse button. */
     ModifierType[ModifierType["BUTTON1_MASK"] = 256] = "BUTTON1_MASK";
+    /** the second mouse button. */
     ModifierType[ModifierType["BUTTON2_MASK"] = 512] = "BUTTON2_MASK";
+    /** the third mouse button. */
     ModifierType[ModifierType["BUTTON3_MASK"] = 1024] = "BUTTON3_MASK";
+    /** the fourth mouse button. */
     ModifierType[ModifierType["BUTTON4_MASK"] = 2048] = "BUTTON4_MASK";
+    /** the fifth mouse button. */
     ModifierType[ModifierType["BUTTON5_MASK"] = 4096] = "BUTTON5_MASK";
+    /** the Super modifier. */
     ModifierType[ModifierType["SUPER_MASK"] = 67108864] = "SUPER_MASK";
+    /** the Hyper modifier. */
     ModifierType[ModifierType["HYPER_MASK"] = 134217728] = "HYPER_MASK";
+    /** the Meta modifier. Maps to Command on macOS. */
     ModifierType[ModifierType["META_MASK"] = 268435456] = "META_MASK";
 })(ModifierType || (ModifierType = {}));
+/**
+ * Flags about a paintable object.
+ *
+ * Implementations use these for optimizations such as caching.
+ */
 export var PaintableFlags;
 (function (PaintableFlags) {
+    /**
+     * The size is immutable.
+     * The [signal@Gdk.Paintable::invalidate-size] signal will never be
+     * emitted.
+     */
     PaintableFlags[PaintableFlags["SIZE"] = 1] = "SIZE";
+    /**
+     * The content is immutable.
+     * The [signal@Gdk.Paintable::invalidate-contents] signal will never be
+     * emitted.
+     */
     PaintableFlags[PaintableFlags["CONTENTS"] = 2] = "CONTENTS";
 })(PaintableFlags || (PaintableFlags = {}));
+/** Flags describing the seat capabilities. */
 export var SeatCapabilities;
 (function (SeatCapabilities) {
+    /** No input capabilities */
     SeatCapabilities[SeatCapabilities["NONE"] = 0] = "NONE";
+    /** The seat has a pointer (e.g. mouse) */
     SeatCapabilities[SeatCapabilities["POINTER"] = 1] = "POINTER";
+    /** The seat has touchscreen(s) attached */
     SeatCapabilities[SeatCapabilities["TOUCH"] = 2] = "TOUCH";
+    /** The seat has drawing tablet(s) attached */
     SeatCapabilities[SeatCapabilities["TABLET_STYLUS"] = 4] = "TABLET_STYLUS";
+    /** The seat has keyboard(s) attached */
     SeatCapabilities[SeatCapabilities["KEYBOARD"] = 8] = "KEYBOARD";
+    /** The seat has drawing tablet pad(s) attached */
     SeatCapabilities[SeatCapabilities["TABLET_PAD"] = 16] = "TABLET_PAD";
+    /** The union of all pointing capabilities */
     SeatCapabilities[SeatCapabilities["ALL_POINTING"] = 7] = "ALL_POINTING";
+    /** The union of all capabilities */
     SeatCapabilities[SeatCapabilities["ALL"] = 31] = "ALL";
 })(SeatCapabilities || (SeatCapabilities = {}));
+/** Reflects what features a `GdkToplevel` supports. */
 export var ToplevelCapabilities;
 (function (ToplevelCapabilities) {
+    /** Whether tiled window states are supported. */
     ToplevelCapabilities[ToplevelCapabilities["EDGE_CONSTRAINTS"] = 1] = "EDGE_CONSTRAINTS";
+    /**
+     * Whether inhibiting system shortcuts is supported.
+     * See [method@Gdk.Toplevel.inhibit_system_shortcuts].
+     */
     ToplevelCapabilities[ToplevelCapabilities["INHIBIT_SHORTCUTS"] = 2] = "INHIBIT_SHORTCUTS";
+    /**
+     * Whether titlebar gestures are supported.
+     * See [method@Gdk.Toplevel.titlebar_gesture].
+     */
     ToplevelCapabilities[ToplevelCapabilities["TITLEBAR_GESTURES"] = 4] = "TITLEBAR_GESTURES";
+    /**
+     * Whether showing the window menu is supported.
+     * See [method@Gdk.Toplevel.show_window_menu].
+     */
     ToplevelCapabilities[ToplevelCapabilities["WINDOW_MENU"] = 8] = "WINDOW_MENU";
+    /** Whether the toplevel can be maximized. */
     ToplevelCapabilities[ToplevelCapabilities["MAXIMIZE"] = 16] = "MAXIMIZE";
+    /** Whether the toplevel can be made fullscreen. */
     ToplevelCapabilities[ToplevelCapabilities["FULLSCREEN"] = 32] = "FULLSCREEN";
+    /**
+     * Whether the toplevel can be minimized.
+     * See [method@Gdk.Toplevel.minimize].
+     */
     ToplevelCapabilities[ToplevelCapabilities["MINIMIZE"] = 64] = "MINIMIZE";
+    /**
+     * Whether the toplevel can be lowered.
+     * See [method@Gdk.Toplevel.lower].
+     */
     ToplevelCapabilities[ToplevelCapabilities["LOWER"] = 128] = "LOWER";
 })(ToplevelCapabilities || (ToplevelCapabilities = {}));
+/**
+ * Specifies the state of a toplevel surface.
+ *
+ * On platforms that support information about individual edges, the
+ * %GDK_TOPLEVEL_STATE_TILED state will be set whenever any of the individual
+ * tiled states is set. On platforms that lack that support, the tiled state
+ * will give an indication of tiledness without any of the per-edge states
+ * being set.
+ */
 export var ToplevelState;
 (function (ToplevelState) {
+    /** the surface is minimized */
     ToplevelState[ToplevelState["MINIMIZED"] = 1] = "MINIMIZED";
+    /** the surface is maximized */
     ToplevelState[ToplevelState["MAXIMIZED"] = 2] = "MAXIMIZED";
+    /** the surface is sticky */
     ToplevelState[ToplevelState["STICKY"] = 4] = "STICKY";
+    /** the surface is maximized without decorations */
     ToplevelState[ToplevelState["FULLSCREEN"] = 8] = "FULLSCREEN";
+    /** the surface is kept above other surfaces */
     ToplevelState[ToplevelState["ABOVE"] = 16] = "ABOVE";
+    /** the surface is kept below other surfaces */
     ToplevelState[ToplevelState["BELOW"] = 32] = "BELOW";
+    /** the surface is presented as focused (with active decorations) */
     ToplevelState[ToplevelState["FOCUSED"] = 64] = "FOCUSED";
+    /** the surface is in a tiled state */
     ToplevelState[ToplevelState["TILED"] = 128] = "TILED";
+    /** whether the top edge is tiled */
     ToplevelState[ToplevelState["TOP_TILED"] = 256] = "TOP_TILED";
+    /** whether the top edge is resizable */
     ToplevelState[ToplevelState["TOP_RESIZABLE"] = 512] = "TOP_RESIZABLE";
+    /** whether the right edge is tiled */
     ToplevelState[ToplevelState["RIGHT_TILED"] = 1024] = "RIGHT_TILED";
+    /** whether the right edge is resizable */
     ToplevelState[ToplevelState["RIGHT_RESIZABLE"] = 2048] = "RIGHT_RESIZABLE";
+    /** whether the bottom edge is tiled */
     ToplevelState[ToplevelState["BOTTOM_TILED"] = 4096] = "BOTTOM_TILED";
+    /** whether the bottom edge is resizable */
     ToplevelState[ToplevelState["BOTTOM_RESIZABLE"] = 8192] = "BOTTOM_RESIZABLE";
+    /** whether the left edge is tiled */
     ToplevelState[ToplevelState["LEFT_TILED"] = 16384] = "LEFT_TILED";
+    /** whether the left edge is resizable */
     ToplevelState[ToplevelState["LEFT_RESIZABLE"] = 32768] = "LEFT_RESIZABLE";
+    /** The surface is not visible to the user. */
     ToplevelState[ToplevelState["SUSPENDED"] = 65536] = "SUSPENDED";
 })(ToplevelState || (ToplevelState = {}));