@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gdk/dndevent.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Drop } from "./drop.js";
 import { Event } from "./event.js";
+/** An event related to drag and drop operations. */
 export class DNDEvent extends Event {
     constructor(...args) {
         super(...args);
@@ -17,6 +18,9 @@ export class DNDEvent extends Event {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the `GdkDrop` object from a DND event.
+     */
     getDrop() {
         const ptr = call("libgtk-4.so.1", "gdk_dnd_event_get_drop", [
             {

package/dist/generated/gdk/drag-surface.d.ts

@@ -1,6 +1,12 @@
+/** A surface that is used during DND. */
 export declare class DragSurface {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): DragSurface;
+    /**
+     * Present @drag_surface.
+     * @param width - the unconstrained drag_surface width to layout
+     * @param height - the unconstrained drag_surface height to layout
+     */
     present(width: number, height: number): boolean;
 }

package/dist/generated/gdk/drag-surface.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+/** A surface that is used during DND. */
 export class DragSurface {
     ptr;
     constructor(ptr) {
@@ -7,6 +8,11 @@ export class DragSurface {
     static fromPtr(ptr) {
         return new DragSurface(ptr);
     }
+    /**
+     * Present @drag_surface.
+     * @param width - the unconstrained drag_surface width to layout
+     * @param height - the unconstrained drag_surface height to layout
+     */
     present(width, height) {
         return call("libgtk-4.so.1", "gdk_drag_surface_present", [
             {

package/dist/generated/gdk/drag.d.ts

@@ -8,16 +8,90 @@ import * as GObject from "../gobject/index.js";
 export declare class Drag extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Starts a drag and creates a new drag context for it.
+     *
+     * This function is called by the drag source. After this call, you
+     * probably want to set up the drag icon using the surface returned
+     * by [method@Gdk.Drag.get_drag_surface].
+     *
+     * This function returns a reference to the [class@Gdk.Drag] object,
+     * but GTK keeps its own reference as well, as long as the DND operation
+     * is going on.
+     *
+     * Note: if `actions` include %GDK_ACTION_MOVE, you need to listen for
+     * the [signal@Gdk.Drag::dnd-finished] signal and delete the data at
+     * the source if [method@Gdk.Drag.get_selected_action] returns
+     * %GDK_ACTION_MOVE.
+     * @param surface - the source surface for this drag
+     * @param device - the device that controls this drag
+     * @param content - the offered content
+     * @param actions - the actions supported by this drag
+     * @param dx - the x offset to @device's position where the drag nominally started
+     * @param dy - the y offset to @device's position where the drag nominally started
+     */
     static begin(surface: Surface, device: Device, content: ContentProvider, actions: DragAction, dx: number, dy: number): Drag;
+    /**
+     * Informs GDK that the drop ended.
+     *
+     * Passing %FALSE for `success` may trigger a drag cancellation
+     * animation.
+     *
+     * This function is called by the drag source, and should be the
+     * last call before dropping the reference to the @drag.
+     *
+     * The `GdkDrag` will only take the first [method@Gdk.Drag.drop_done]
+     * call as effective, if this function is called multiple times,
+     * all subsequent calls will be ignored.
+     * @param success - whether the drag was ultimatively successful
+     */
     dropDone(success: boolean): void;
+    /**
+     * Determines the bitmask of possible actions proposed by the source.
+     */
     getActions(): DragAction;
+    /**
+     * Returns the `GdkContentProvider` associated to the `GdkDrag` object.
+     */
     getContent(): ContentProvider;
+    /**
+     * Returns the `GdkDevice` associated to the `GdkDrag` object.
+     */
     getDevice(): Device;
+    /**
+     * Gets the `GdkDisplay` that the drag object was created for.
+     */
     getDisplay(): Display;
+    /**
+     * Returns the surface on which the drag icon should be rendered
+     * during the drag operation.
+     *
+     * Note that the surface may not be available until the drag operation
+     * has begun. GDK will move the surface in accordance with the ongoing
+     * drag operation. The surface is owned by `drag` and will be destroyed
+     * when the drag operation is over.
+     */
     getDragSurface(): Surface | null;
+    /**
+     * Retrieves the formats supported by this `GdkDrag` object.
+     */
     getFormats(): ContentFormats;
+    /**
+     * Determines the action chosen by the drag destination.
+     */
     getSelectedAction(): DragAction;
+    /**
+     * Returns the `GdkSurface` where the drag originates.
+     */
     getSurface(): Surface;
+    /**
+     * Sets the position of the drag surface that will be kept
+     * under the cursor hotspot.
+     *
+     * Initially, the hotspot is at the top left corner of the drag surface.
+     * @param hotX - x coordinate of the drag surface hotspot
+     * @param hotY - y coordinate of the drag surface hotspot
+     */
     setHotspot(hotX: number, hotY: number): void;
     connect(signal: "cancel", handler: (self: Drag, reason: DragCancelReason) => void, after?: boolean): number;
     connect(signal: "dnd-finished", handler: (self: Drag) => void, after?: boolean): number;

package/dist/generated/gdk/drag.js

@@ -6,6 +6,18 @@ import { Device } from "./device.js";
 import { Display } from "./display.js";
 import { Surface } from "./surface.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Represents the source of an ongoing DND operation.
+ *
+ * A `GdkDrag` is created when a drag is started, and stays alive for duration of
+ * the DND operation. After a drag has been started with [func@Gdk.Drag.begin],
+ * the caller gets informed about the status of the ongoing drag operation
+ * with signals on the `GdkDrag` object.
+ *
+ * GTK provides a higher level abstraction based on top of these functions,
+ * and so they are not normally needed in GTK applications. See the
+ * "Drag and Drop" section of the GTK documentation for more information.
+ */
 const SIGNAL_META = {
     cancel: {
         params: [{ type: { type: "int", size: 32, unsigned: false } }],
@@ -29,6 +41,28 @@ export class Drag extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Starts a drag and creates a new drag context for it.
+     *
+     * This function is called by the drag source. After this call, you
+     * probably want to set up the drag icon using the surface returned
+     * by [method@Gdk.Drag.get_drag_surface].
+     *
+     * This function returns a reference to the [class@Gdk.Drag] object,
+     * but GTK keeps its own reference as well, as long as the DND operation
+     * is going on.
+     *
+     * Note: if `actions` include %GDK_ACTION_MOVE, you need to listen for
+     * the [signal@Gdk.Drag::dnd-finished] signal and delete the data at
+     * the source if [method@Gdk.Drag.get_selected_action] returns
+     * %GDK_ACTION_MOVE.
+     * @param surface - the source surface for this drag
+     * @param device - the device that controls this drag
+     * @param content - the offered content
+     * @param actions - the actions supported by this drag
+     * @param dx - the x offset to @device's position where the drag nominally started
+     * @param dy - the y offset to @device's position where the drag nominally started
+     */
     static begin(surface, device, content, actions, dx, dy) {
         const ptr = call("libgtk-4.so.1", "gdk_drag_begin", [
             {
@@ -58,6 +92,20 @@ export class Drag extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Drag);
     }
+    /**
+     * Informs GDK that the drop ended.
+     *
+     * Passing %FALSE for `success` may trigger a drag cancellation
+     * animation.
+     *
+     * This function is called by the drag source, and should be the
+     * last call before dropping the reference to the @drag.
+     *
+     * The `GdkDrag` will only take the first [method@Gdk.Drag.drop_done]
+     * call as effective, if this function is called multiple times,
+     * all subsequent calls will be ignored.
+     * @param success - whether the drag was ultimatively successful
+     */
     dropDone(success) {
         call("libgtk-4.so.1", "gdk_drag_drop_done", [
             {
@@ -70,6 +118,9 @@ export class Drag extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines the bitmask of possible actions proposed by the source.
+     */
     getActions() {
         return call("libgtk-4.so.1", "gdk_drag_get_actions", [
             {
@@ -78,6 +129,9 @@ export class Drag extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the `GdkContentProvider` associated to the `GdkDrag` object.
+     */
     getContent() {
         const ptr = call("libgtk-4.so.1", "gdk_drag_get_content", [
             {
@@ -87,6 +141,9 @@ export class Drag extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, ContentProvider);
     }
+    /**
+     * Returns the `GdkDevice` associated to the `GdkDrag` object.
+     */
     getDevice() {
         const ptr = call("libgtk-4.so.1", "gdk_drag_get_device", [
             {
@@ -96,6 +153,9 @@ export class Drag extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Device);
     }
+    /**
+     * Gets the `GdkDisplay` that the drag object was created for.
+     */
     getDisplay() {
         const ptr = call("libgtk-4.so.1", "gdk_drag_get_display", [
             {
@@ -105,6 +165,15 @@ export class Drag extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Display);
     }
+    /**
+     * Returns the surface on which the drag icon should be rendered
+     * during the drag operation.
+     *
+     * Note that the surface may not be available until the drag operation
+     * has begun. GDK will move the surface in accordance with the ongoing
+     * drag operation. The surface is owned by `drag` and will be destroyed
+     * when the drag operation is over.
+     */
     getDragSurface() {
         const ptr = call("libgtk-4.so.1", "gdk_drag_get_drag_surface", [
             {
@@ -116,6 +185,9 @@ export class Drag extends GObject.GObject {
             return null;
         return getObject(ptr, Surface);
     }
+    /**
+     * Retrieves the formats supported by this `GdkDrag` object.
+     */
     getFormats() {
         const ptr = call("libgtk-4.so.1", "gdk_drag_get_formats", [
             {
@@ -130,6 +202,9 @@ export class Drag extends GObject.GObject {
         });
         return getObject(ptr, ContentFormats);
     }
+    /**
+     * Determines the action chosen by the drag destination.
+     */
     getSelectedAction() {
         return call("libgtk-4.so.1", "gdk_drag_get_selected_action", [
             {
@@ -138,6 +213,9 @@ export class Drag extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the `GdkSurface` where the drag originates.
+     */
     getSurface() {
         const ptr = call("libgtk-4.so.1", "gdk_drag_get_surface", [
             {
@@ -147,6 +225,14 @@ export class Drag extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Surface);
     }
+    /**
+     * Sets the position of the drag surface that will be kept
+     * under the cursor hotspot.
+     *
+     * Initially, the hotspot is at the top left corner of the drag surface.
+     * @param hotX - x coordinate of the drag surface hotspot
+     * @param hotY - y coordinate of the drag surface hotspot
+     */
     setHotspot(hotX, hotY) {
         call("libgtk-4.so.1", "gdk_drag_set_hotspot", [
             {

package/dist/generated/gdk/draw-context.d.ts

@@ -2,14 +2,84 @@ import { Display } from "./display.js";
 import { Surface } from "./surface.js";
 import * as GObject from "../gobject/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * Base class for objects implementing different rendering methods.
+ *
+ * `GdkDrawContext` is the base object used by contexts implementing different
+ * rendering methods, such as [class@Gdk.CairoContext] or [class@Gdk.GLContext].
+ * It provides shared functionality between those contexts.
+ *
+ * You will always interact with one of those subclasses.
+ *
+ * A `GdkDrawContext` is always associated with a single toplevel surface.
+ */
 export declare class DrawContext extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Indicates that you are beginning the process of redrawing `region` on the @context's surface.
+     *
+     * Calling this function begins a drawing operation using `context` on the
+     * surface that `context` was created from. The actual requirements and
+     * guarantees for the drawing operation vary for different implementations
+     * of drawing, so a [class@Gdk.CairoContext] and a [class@Gdk.GLContext]
+     * need to be treated differently.
+     *
+     * A call to this function is a requirement for drawing and must be
+     * followed by a call to [method@Gdk.DrawContext.end_frame], which will
+     * complete the drawing operation and ensure the contents become visible
+     * on screen.
+     *
+     * Note that the `region` passed to this function is the minimum region that
+     * needs to be drawn and depending on implementation, windowing system and
+     * hardware in use, it might be necessary to draw a larger region. Drawing
+     * implementation must use [method@Gdk.DrawContext.get_frame_region] to
+     * query the region that must be drawn.
+     *
+     * When using GTK, the widget system automatically places calls to
+     * gdk_draw_context_begin_frame() and gdk_draw_context_end_frame() via the
+     * use of GskRenderers, so application code
+     * does not need to call these functions explicitly.
+     * @param region - minimum region that should be drawn
+     */
     beginFrame(region: cairo.Region): void;
+    /**
+     * Ends a drawing operation started with gdk_draw_context_begin_frame().
+     *
+     * This makes the drawing available on screen.
+     * See [method@Gdk.DrawContext.begin_frame] for more details about drawing.
+     *
+     * When using a [class@Gdk.GLContext], this function may call `glFlush()`
+     * implicitly before returning; it is not recommended to call `glFlush()`
+     * explicitly before calling this function.
+     */
     endFrame(): void;
+    /**
+     * Retrieves the `GdkDisplay` the `context` is created for
+     */
     getDisplay(): Display | null;
+    /**
+     * Retrieves the region that is currently being repainted.
+     *
+     * After a call to [method@Gdk.DrawContext.begin_frame] this function will
+     * return a union of the region passed to that function and the area of the
+     * surface that the `context` determined needs to be repainted.
+     *
+     * If `context` is not in between calls to [method@Gdk.DrawContext.begin_frame]
+     * and [method@Gdk.DrawContext.end_frame], %NULL will be returned.
+     */
     getFrameRegion(): cairo.Region | null;
+    /**
+     * Retrieves the surface that `context` is bound to.
+     */
     getSurface(): Surface | null;
+    /**
+     * Returns %TRUE if `context` is in the process of drawing to its surface.
+     *
+     * This is the case between calls to [method@Gdk.DrawContext.begin_frame]
+     * and [method@Gdk.DrawContext.end_frame]. In this situation, drawing commands
+     * may be effecting the contents of the @context's surface.
+     */
     isInFrame(): boolean;
     connect(signal: "notify", handler: (self: DrawContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gdk/draw-context.js

@@ -4,6 +4,17 @@ import { Display } from "./display.js";
 import { Surface } from "./surface.js";
 import * as GObject from "../gobject/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * Base class for objects implementing different rendering methods.
+ *
+ * `GdkDrawContext` is the base object used by contexts implementing different
+ * rendering methods, such as [class@Gdk.CairoContext] or [class@Gdk.GLContext].
+ * It provides shared functionality between those contexts.
+ *
+ * You will always interact with one of those subclasses.
+ *
+ * A `GdkDrawContext` is always associated with a single toplevel surface.
+ */
 export class DrawContext extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -19,6 +30,32 @@ export class DrawContext extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Indicates that you are beginning the process of redrawing `region` on the @context's surface.
+     *
+     * Calling this function begins a drawing operation using `context` on the
+     * surface that `context` was created from. The actual requirements and
+     * guarantees for the drawing operation vary for different implementations
+     * of drawing, so a [class@Gdk.CairoContext] and a [class@Gdk.GLContext]
+     * need to be treated differently.
+     *
+     * A call to this function is a requirement for drawing and must be
+     * followed by a call to [method@Gdk.DrawContext.end_frame], which will
+     * complete the drawing operation and ensure the contents become visible
+     * on screen.
+     *
+     * Note that the `region` passed to this function is the minimum region that
+     * needs to be drawn and depending on implementation, windowing system and
+     * hardware in use, it might be necessary to draw a larger region. Drawing
+     * implementation must use [method@Gdk.DrawContext.get_frame_region] to
+     * query the region that must be drawn.
+     *
+     * When using GTK, the widget system automatically places calls to
+     * gdk_draw_context_begin_frame() and gdk_draw_context_end_frame() via the
+     * use of GskRenderers, so application code
+     * does not need to call these functions explicitly.
+     * @param region - minimum region that should be drawn
+     */
     beginFrame(region) {
         call("libgtk-4.so.1", "gdk_draw_context_begin_frame", [
             {
@@ -36,6 +73,16 @@ export class DrawContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Ends a drawing operation started with gdk_draw_context_begin_frame().
+     *
+     * This makes the drawing available on screen.
+     * See [method@Gdk.DrawContext.begin_frame] for more details about drawing.
+     *
+     * When using a [class@Gdk.GLContext], this function may call `glFlush()`
+     * implicitly before returning; it is not recommended to call `glFlush()`
+     * explicitly before calling this function.
+     */
     endFrame() {
         call("libgtk-4.so.1", "gdk_draw_context_end_frame", [
             {
@@ -44,6 +91,9 @@ export class DrawContext extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the `GdkDisplay` the `context` is created for
+     */
     getDisplay() {
         const ptr = call("libgtk-4.so.1", "gdk_draw_context_get_display", [
             {
@@ -55,6 +105,16 @@ export class DrawContext extends GObject.GObject {
             return null;
         return getObject(ptr, Display);
     }
+    /**
+     * Retrieves the region that is currently being repainted.
+     *
+     * After a call to [method@Gdk.DrawContext.begin_frame] this function will
+     * return a union of the region passed to that function and the area of the
+     * surface that the `context` determined needs to be repainted.
+     *
+     * If `context` is not in between calls to [method@Gdk.DrawContext.begin_frame]
+     * and [method@Gdk.DrawContext.end_frame], %NULL will be returned.
+     */
     getFrameRegion() {
         const ptr = call("libgtk-4.so.1", "gdk_draw_context_get_frame_region", [
             {
@@ -71,6 +131,9 @@ export class DrawContext extends GObject.GObject {
             return null;
         return getObject(ptr, cairo.Region);
     }
+    /**
+     * Retrieves the surface that `context` is bound to.
+     */
     getSurface() {
         const ptr = call("libgtk-4.so.1", "gdk_draw_context_get_surface", [
             {
@@ -82,6 +145,13 @@ export class DrawContext extends GObject.GObject {
             return null;
         return getObject(ptr, Surface);
     }
+    /**
+     * Returns %TRUE if `context` is in the process of drawing to its surface.
+     *
+     * This is the case between calls to [method@Gdk.DrawContext.begin_frame]
+     * and [method@Gdk.DrawContext.end_frame]. In this situation, drawing commands
+     * may be effecting the contents of the @context's surface.
+     */
     isInFrame() {
         return call("libgtk-4.so.1", "gdk_draw_context_is_in_frame", [
             {

package/dist/generated/gdk/drop.d.ts

@@ -7,18 +7,111 @@ import { Drag } from "./drag.js";
 import { Surface } from "./surface.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * Represents the target of an ongoing DND operation.
+ *
+ * Possible drop sites get informed about the status of the ongoing drag
+ * operation with events of type `GDK_DRAG_ENTER`, `GDK_DRAG_LEAVE`,
+ * `GDK_DRAG_MOTION` and `GDK_DROP_START`. The `GdkDrop` object can be obtained
+ * from these [class@Gdk.Event] types using [method@Gdk.DNDEvent.get_drop].
+ *
+ * The actual data transfer is initiated from the target side via an async
+ * read, using one of the `GdkDrop` methods for this purpose:
+ * [method@Gdk.Drop.read_async] or [method@Gdk.Drop.read_value_async].
+ *
+ * GTK provides a higher level abstraction based on top of these functions,
+ * and so they are not normally needed in GTK applications. See the
+ * "Drag and Drop" section of the GTK documentation for more information.
+ */
 export declare class Drop extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Ends the drag operation after a drop.
+     *
+     * The `action` must be a single action selected from the actions
+     * available via [method@Gdk.Drop.get_actions].
+     * @param action - the action performed by the destination or `GDK_ACTION_NONE` if the
+     */
     finish(action: DragAction): void;
+    /**
+     * Returns the possible actions for this `GdkDrop`.
+     *
+     * If this value contains multiple actions - i.e.
+     * [func@Gdk.DragAction.is_unique] returns false for the result -
+     * [method@Gdk.Drop.finish] must choose the action to use when
+     * accepting the drop. This will only happen if you passed
+     * `GDK_ACTION_ASK` as one of the possible actions in
+     * [method@Gdk.Drop.status]. `GDK_ACTION_ASK` itself will not
+     * be included in the actions returned by this function.
+     *
+     * This value may change over the lifetime of the [class@Gdk.Drop]
+     * both as a response to source side actions as well as to calls to
+     * [method@Gdk.Drop.status] or [method@Gdk.Drop.finish]. The source
+     * side will not change this value anymore once a drop has started.
+     */
     getActions(): DragAction;
+    /**
+     * Returns the `GdkDevice` performing the drop.
+     */
     getDevice(): Device;
+    /**
+     * Gets the `GdkDisplay` that `self` was created for.
+     */
     getDisplay(): Display;
+    /**
+     * If this is an in-app drag-and-drop operation, returns the `GdkDrag`
+     * that corresponds to this drop.
+     *
+     * If it is not, `NULL` is returned.
+     */
     getDrag(): Drag | null;
+    /**
+     * Returns the `GdkContentFormats` that the drop offers the data
+     * to be read in.
+     */
     getFormats(): ContentFormats;
+    /**
+     * Returns the `GdkSurface` performing the drop.
+     */
     getSurface(): Surface;
+    /**
+     * Finishes an async drop read operation.
+     *
+     * Note that you must not use blocking read calls on the returned stream
+     * in the GTK thread, since some platforms might require communication with
+     * GTK to complete the data transfer. You can use async APIs such as
+     * g_input_stream_read_bytes_async().
+     *
+     * See [method@Gdk.Drop.read_async].
+     * @param result - a `GAsyncResult`
+     * @param outMimeType - return location for the used mime type
+     */
     readFinish(result: Gio.AsyncResult, outMimeType: Ref<string>): Gio.InputStream | null;
+    /**
+     * Finishes an async drop read.
+     *
+     * See [method@Gdk.Drop.read_value_async].
+     * @param result - a `GAsyncResult`
+     */
     readValueFinish(result: Gio.AsyncResult): GObject.Value;
+    /**
+     * Selects all actions that are potentially supported by the destination.
+     *
+     * When calling this function, do not restrict the passed in actions to
+     * the ones provided by [method@Gdk.Drop.get_actions]. Those actions may
+     * change in the future, even depending on the actions you provide here.
+     *
+     * The `preferred` action is a hint to the drag-and-drop mechanism about which
+     * action to use when multiple actions are possible.
+     *
+     * This function should be called by drag destinations in response to
+     * `GDK_DRAG_ENTER` or `GDK_DRAG_MOTION` events. If the destination does
+     * not yet know the exact actions it supports, it should set any possible
+     * actions first and then later call this function again.
+     * @param actions - Supported actions of the destination, or `GDK_ACTION_NONE` to
+     * @param preferred - A unique action that's a member of `actions` indicating the
+     */
     status(actions: DragAction, preferred: DragAction): void;
     connect(signal: "notify", handler: (self: Drop, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;