@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,6 +1,16 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { DrawContext } from "./draw-context.js";
+/**
+ * Represents the platform-specific Vulkan draw context.
+ *
+ * `GdkVulkanContext`s are created for a surface using
+ * [method@Gdk.Surface.create_vulkan_context], and the context will match
+ * the characteristics of the surface.
+ *
+ * Support for `GdkVulkanContext` is platform-specific and context creation
+ * can fail, returning %NULL context.
+ */
 const SIGNAL_META = {
     "images-updated": { params: [], returnType: { type: "undefined" } },
 };

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

@@ -1,33 +1,139 @@
+/**
+ * This enumeration defines the color spaces that are supported by
+ * the gdk-pixbuf library.
+ *
+ * Currently only RGB is supported.
+ */
 export declare enum Colorspace {
+    /** Indicates a red/green/blue additive color space. */
     RGB = 0
 }
+/**
+ * Interpolation modes for scaling functions.
+ *
+ * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has
+ * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best
+ * choice if you aren't sure what to choose, it has a good speed/quality
+ * balance.
+ *
+ * **Note**: Cubic filtering is missing from the list; hyperbolic
+ * interpolation is just as fast and results in higher quality.
+ */
 export declare enum InterpType {
+    /**
+     * Nearest neighbor sampling; this is the fastest
+     * and lowest quality mode. Quality is normally unacceptable when scaling
+     * down, but may be OK when scaling up.
+     */
     NEAREST = 0,
+    /**
+     * This is an accurate simulation of the PostScript
+     * image operator without any interpolation enabled.  Each pixel is
+     * rendered as a tiny parallelogram of solid color, the edges of which
+     * are implemented with antialiasing.  It resembles nearest neighbor for
+     * enlargement, and bilinear for reduction.
+     */
     TILES = 1,
+    /**
+     * Best quality/speed balance; use this mode by
+     * default. Bilinear interpolation.  For enlargement, it is
+     * equivalent to point-sampling the ideal bilinear-interpolated image.
+     * For reduction, it is equivalent to laying down small tiles and
+     * integrating over the coverage area.
+     */
     BILINEAR = 2,
+    /**
+     * This is the slowest and highest quality
+     * reconstruction function. It is derived from the hyperbolic filters in
+     * Wolberg's "Digital Image Warping", and is formally defined as the
+     * hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
+     * image (the filter is designed to be idempotent for 1:1 pixel mapping).
+     * **Deprecated**: this interpolation filter is deprecated, as in reality
+     * it has a lower quality than the `GDK_INTERP_BILINEAR` filter
+     * (Since: 2.38)
+     */
     HYPER = 3
 }
+/**
+ * Control the alpha channel for drawables.
+ *
+ * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha()
+ * in gdk-pixbuf-xlib to control how the alpha channel of an image should
+ * be handled.
+ *
+ * This function can create a bilevel clipping mask (black and white) and use
+ * it while painting the image.
+ *
+ * In the future, when the X Window System gets an alpha channel extension,
+ * it will be possible to do full alpha compositing onto arbitrary drawables.
+ * For now both cases fall back to a bilevel clipping mask.
+ */
 export declare enum PixbufAlphaMode {
+    /**
+     * A bilevel clipping mask (black and white)
+     * will be created and used to draw the image.  Pixels below 0.5 opacity
+     * will be considered fully transparent, and all others will be
+     * considered fully opaque.
+     */
     BILEVEL = 0,
+    /**
+     * For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
+     * In the future it will do full alpha compositing.
+     */
     FULL = 1
 }
+/**
+ * An error code in the `GDK_PIXBUF_ERROR` domain.
+ *
+ * Many gdk-pixbuf operations can cause errors in this domain, or in
+ * the `G_FILE_ERROR` domain.
+ */
 export declare enum PixbufError {
+    /** An image file was broken somehow. */
     CORRUPT_IMAGE = 0,
+    /** Not enough memory. */
     INSUFFICIENT_MEMORY = 1,
+    /** A bad option was passed to a pixbuf save module. */
     BAD_OPTION = 2,
+    /** Unknown image type. */
     UNKNOWN_TYPE = 3,
+    /**
+     * Don't know how to perform the
+     * given operation on the type of image at hand.
+     */
     UNSUPPORTED_OPERATION = 4,
+    /** Generic failure code, something went wrong. */
     FAILED = 5,
+    /** Only part of the animation was loaded. */
     INCOMPLETE_ANIMATION = 6
 }
+/**
+ * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
+ *
+ * To make them easier to use, their numerical values are the actual degrees.
+ */
 export declare enum PixbufRotation {
+    /** No rotation. */
     NONE = 0,
+    /** Rotate by 90 degrees. */
     COUNTERCLOCKWISE = 90,
+    /** Rotate by 180 degrees. */
     UPSIDEDOWN = 180,
+    /** Rotate by 270 degrees. */
     CLOCKWISE = 270
 }
+/**
+ * Flags which allow a module to specify further details about the supported
+ * operations.
+ */
 export declare enum PixbufFormatFlags {
+    /** the module can write out images in the format. */
     WRITABLE = 1,
+    /** the image format is scalable */
     SCALABLE = 2,
+    /**
+     * the module is threadsafe. gdk-pixbuf
+     * ignores modules that are not marked as threadsafe. (Since 2.28).
+     */
     THREADSAFE = 4
 }

package/dist/generated/gdkpixbuf/enums.js

@@ -1,39 +1,145 @@
+/**
+ * This enumeration defines the color spaces that are supported by
+ * the gdk-pixbuf library.
+ *
+ * Currently only RGB is supported.
+ */
 export var Colorspace;
 (function (Colorspace) {
+    /** Indicates a red/green/blue additive color space. */
     Colorspace[Colorspace["RGB"] = 0] = "RGB";
 })(Colorspace || (Colorspace = {}));
+/**
+ * Interpolation modes for scaling functions.
+ *
+ * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has
+ * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best
+ * choice if you aren't sure what to choose, it has a good speed/quality
+ * balance.
+ *
+ * **Note**: Cubic filtering is missing from the list; hyperbolic
+ * interpolation is just as fast and results in higher quality.
+ */
 export var InterpType;
 (function (InterpType) {
+    /**
+     * Nearest neighbor sampling; this is the fastest
+     * and lowest quality mode. Quality is normally unacceptable when scaling
+     * down, but may be OK when scaling up.
+     */
     InterpType[InterpType["NEAREST"] = 0] = "NEAREST";
+    /**
+     * This is an accurate simulation of the PostScript
+     * image operator without any interpolation enabled.  Each pixel is
+     * rendered as a tiny parallelogram of solid color, the edges of which
+     * are implemented with antialiasing.  It resembles nearest neighbor for
+     * enlargement, and bilinear for reduction.
+     */
     InterpType[InterpType["TILES"] = 1] = "TILES";
+    /**
+     * Best quality/speed balance; use this mode by
+     * default. Bilinear interpolation.  For enlargement, it is
+     * equivalent to point-sampling the ideal bilinear-interpolated image.
+     * For reduction, it is equivalent to laying down small tiles and
+     * integrating over the coverage area.
+     */
     InterpType[InterpType["BILINEAR"] = 2] = "BILINEAR";
+    /**
+     * This is the slowest and highest quality
+     * reconstruction function. It is derived from the hyperbolic filters in
+     * Wolberg's "Digital Image Warping", and is formally defined as the
+     * hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
+     * image (the filter is designed to be idempotent for 1:1 pixel mapping).
+     * **Deprecated**: this interpolation filter is deprecated, as in reality
+     * it has a lower quality than the `GDK_INTERP_BILINEAR` filter
+     * (Since: 2.38)
+     */
     InterpType[InterpType["HYPER"] = 3] = "HYPER";
 })(InterpType || (InterpType = {}));
+/**
+ * Control the alpha channel for drawables.
+ *
+ * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha()
+ * in gdk-pixbuf-xlib to control how the alpha channel of an image should
+ * be handled.
+ *
+ * This function can create a bilevel clipping mask (black and white) and use
+ * it while painting the image.
+ *
+ * In the future, when the X Window System gets an alpha channel extension,
+ * it will be possible to do full alpha compositing onto arbitrary drawables.
+ * For now both cases fall back to a bilevel clipping mask.
+ */
 export var PixbufAlphaMode;
 (function (PixbufAlphaMode) {
+    /**
+     * A bilevel clipping mask (black and white)
+     * will be created and used to draw the image.  Pixels below 0.5 opacity
+     * will be considered fully transparent, and all others will be
+     * considered fully opaque.
+     */
     PixbufAlphaMode[PixbufAlphaMode["BILEVEL"] = 0] = "BILEVEL";
+    /**
+     * For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
+     * In the future it will do full alpha compositing.
+     */
     PixbufAlphaMode[PixbufAlphaMode["FULL"] = 1] = "FULL";
 })(PixbufAlphaMode || (PixbufAlphaMode = {}));
+/**
+ * An error code in the `GDK_PIXBUF_ERROR` domain.
+ *
+ * Many gdk-pixbuf operations can cause errors in this domain, or in
+ * the `G_FILE_ERROR` domain.
+ */
 export var PixbufError;
 (function (PixbufError) {
+    /** An image file was broken somehow. */
     PixbufError[PixbufError["CORRUPT_IMAGE"] = 0] = "CORRUPT_IMAGE";
+    /** Not enough memory. */
     PixbufError[PixbufError["INSUFFICIENT_MEMORY"] = 1] = "INSUFFICIENT_MEMORY";
+    /** A bad option was passed to a pixbuf save module. */
     PixbufError[PixbufError["BAD_OPTION"] = 2] = "BAD_OPTION";
+    /** Unknown image type. */
     PixbufError[PixbufError["UNKNOWN_TYPE"] = 3] = "UNKNOWN_TYPE";
+    /**
+     * Don't know how to perform the
+     * given operation on the type of image at hand.
+     */
     PixbufError[PixbufError["UNSUPPORTED_OPERATION"] = 4] = "UNSUPPORTED_OPERATION";
+    /** Generic failure code, something went wrong. */
     PixbufError[PixbufError["FAILED"] = 5] = "FAILED";
+    /** Only part of the animation was loaded. */
     PixbufError[PixbufError["INCOMPLETE_ANIMATION"] = 6] = "INCOMPLETE_ANIMATION";
 })(PixbufError || (PixbufError = {}));
+/**
+ * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
+ *
+ * To make them easier to use, their numerical values are the actual degrees.
+ */
 export var PixbufRotation;
 (function (PixbufRotation) {
+    /** No rotation. */
     PixbufRotation[PixbufRotation["NONE"] = 0] = "NONE";
+    /** Rotate by 90 degrees. */
     PixbufRotation[PixbufRotation["COUNTERCLOCKWISE"] = 90] = "COUNTERCLOCKWISE";
+    /** Rotate by 180 degrees. */
     PixbufRotation[PixbufRotation["UPSIDEDOWN"] = 180] = "UPSIDEDOWN";
+    /** Rotate by 270 degrees. */
     PixbufRotation[PixbufRotation["CLOCKWISE"] = 270] = "CLOCKWISE";
 })(PixbufRotation || (PixbufRotation = {}));
+/**
+ * Flags which allow a module to specify further details about the supported
+ * operations.
+ */
 export var PixbufFormatFlags;
 (function (PixbufFormatFlags) {
+    /** the module can write out images in the format. */
     PixbufFormatFlags[PixbufFormatFlags["WRITABLE"] = 1] = "WRITABLE";
+    /** the image format is scalable */
     PixbufFormatFlags[PixbufFormatFlags["SCALABLE"] = 2] = "SCALABLE";
+    /**
+     * the module is threadsafe. gdk-pixbuf
+     * ignores modules that are not marked as threadsafe. (Since 2.28).
+     */
     PixbufFormatFlags[PixbufFormatFlags["THREADSAFE"] = 4] = "THREADSAFE";
 })(PixbufFormatFlags || (PixbufFormatFlags = {}));

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.d.ts

@@ -1,11 +1,75 @@
 import { Pixbuf } from "./pixbuf.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * An opaque object representing an iterator which points to a
+ * certain position in an animation.
+ */
 export declare class PixbufAnimationIter extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Possibly advances an animation to a new frame.
+     *
+     * Chooses the frame based on the start time passed to
+     * gdk_pixbuf_animation_get_iter().
+     *
+     * `current_time` would normally come from g_get_current_time(), and
+     * must be greater than or equal to the time passed to
+     * gdk_pixbuf_animation_get_iter(), and must increase or remain
+     * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
+     * called. That is, you can't go backward in time; animations only
+     * play forward.
+     *
+     * As a shortcut, pass `NULL` for the current time and g_get_current_time()
+     * will be invoked on your behalf. So you only need to explicitly pass
+     * `current_time` if you're doing something odd like playing the animation
+     * at double speed.
+     *
+     * If this function returns `FALSE`, there's no need to update the animation
+     * display, assuming the display had been rendered prior to advancing;
+     * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
+     * and update the display with the new pixbuf.
+     * @param currentTime - current time
+     */
     advance(currentTime?: number | null): boolean;
+    /**
+     * Gets the number of milliseconds the current pixbuf should be displayed,
+     * or -1 if the current pixbuf should be displayed forever.
+     *
+     * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
+     * so you can use a timeout to schedule the next update.
+     *
+     * Note that some formats, like GIF, might clamp the timeout values in the
+     * image file to avoid updates that are just too quick. The minimum timeout
+     * for GIF images is currently 20 milliseconds.
+     */
     getDelayTime(): number;
+    /**
+     * Gets the current pixbuf which should be displayed.
+     *
+     * The pixbuf might not be the same size as the animation itself
+     * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
+     *
+     * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
+     * milliseconds.
+     *
+     * The caller of this function does not own a reference to the returned
+     * pixbuf; the returned pixbuf will become invalid when the iterator
+     * advances to the next frame, which may happen anytime you call
+     * gdk_pixbuf_animation_iter_advance().
+     *
+     * Copy the pixbuf to keep it (don't just add a reference), as it may get
+     * recycled as you advance the iterator.
+     */
     getPixbuf(): Pixbuf;
+    /**
+     * Used to determine how to respond to the area_updated signal on
+     * #GdkPixbufLoader when loading an animation.
+     *
+     * The `::area_updated` signal is emitted for an area of the frame currently
+     * streaming in to the loader. So if you're on the currently loading frame,
+     * you will need to redraw the screen for the updated area.
+     */
     onCurrentlyLoadingFrame(): boolean;
     connect(signal: "notify", handler: (self: PixbufAnimationIter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.js

@@ -2,6 +2,10 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Pixbuf } from "./pixbuf.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * An opaque object representing an iterator which points to a
+ * certain position in an animation.
+ */
 export class PixbufAnimationIter extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -13,6 +17,30 @@ export class PixbufAnimationIter extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Possibly advances an animation to a new frame.
+     *
+     * Chooses the frame based on the start time passed to
+     * gdk_pixbuf_animation_get_iter().
+     *
+     * `current_time` would normally come from g_get_current_time(), and
+     * must be greater than or equal to the time passed to
+     * gdk_pixbuf_animation_get_iter(), and must increase or remain
+     * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
+     * called. That is, you can't go backward in time; animations only
+     * play forward.
+     *
+     * As a shortcut, pass `NULL` for the current time and g_get_current_time()
+     * will be invoked on your behalf. So you only need to explicitly pass
+     * `current_time` if you're doing something odd like playing the animation
+     * at double speed.
+     *
+     * If this function returns `FALSE`, there's no need to update the animation
+     * display, assuming the display had been rendered prior to advancing;
+     * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
+     * and update the display with the new pixbuf.
+     * @param currentTime - current time
+     */
     advance(currentTime) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_advance", [
             {
@@ -26,6 +54,17 @@ export class PixbufAnimationIter extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the number of milliseconds the current pixbuf should be displayed,
+     * or -1 if the current pixbuf should be displayed forever.
+     *
+     * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
+     * so you can use a timeout to schedule the next update.
+     *
+     * Note that some formats, like GIF, might clamp the timeout values in the
+     * image file to avoid updates that are just too quick. The minimum timeout
+     * for GIF images is currently 20 milliseconds.
+     */
     getDelayTime() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_get_delay_time", [
             {
@@ -34,6 +73,23 @@ export class PixbufAnimationIter extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the current pixbuf which should be displayed.
+     *
+     * The pixbuf might not be the same size as the animation itself
+     * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
+     *
+     * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
+     * milliseconds.
+     *
+     * The caller of this function does not own a reference to the returned
+     * pixbuf; the returned pixbuf will become invalid when the iterator
+     * advances to the next frame, which may happen anytime you call
+     * gdk_pixbuf_animation_iter_advance().
+     *
+     * Copy the pixbuf to keep it (don't just add a reference), as it may get
+     * recycled as you advance the iterator.
+     */
     getPixbuf() {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_get_pixbuf", [
             {
@@ -43,6 +99,14 @@ export class PixbufAnimationIter extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Used to determine how to respond to the area_updated signal on
+     * #GdkPixbufLoader when loading an animation.
+     *
+     * The `::area_updated` signal is emitted for an area of the frame currently
+     * streaming in to the loader. So if you're on the currently loading frame,
+     * you will need to redraw the screen for the updated area.
+     */
     onCurrentlyLoadingFrame() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_on_currently_loading_frame", [
             {

package/dist/generated/gdkpixbuf/pixbuf-animation.d.ts

@@ -2,18 +2,150 @@ import { Pixbuf } from "./pixbuf.js";
 import { PixbufAnimationIter } from "./pixbuf-animation-iter.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * An opaque object representing an animation.
+ *
+ * The GdkPixBuf library provides a simple mechanism to load and
+ * represent animations. An animation is conceptually a series of
+ * frames to be displayed over time.
+ *
+ * The animation may not be represented as a series of frames
+ * internally; for example, it may be stored as a sprite and
+ * instructions for moving the sprite around a background.
+ *
+ * To display an animation you don't need to understand its
+ * representation, however; you just ask `GdkPixbuf` what should
+ * be displayed at a given point in time.
+ */
 export declare class PixbufAnimation extends GObject.GObject {
+    /**
+     * Creates a new animation by loading it from a file.
+     *
+     * The file format is detected automatically.
+     *
+     * If the file's format does not support multi-frame images, then an animation
+     * with a single frame will be created.
+     *
+     * Possible errors are in the `GDK_PIXBUF_ERROR` and `G_FILE_ERROR` domains.
+     * @param filename - Name of file to load, in the GLib file
+     */
     constructor(filename: string);
     constructor(...args: unknown[]);
+    /**
+     * Creates a new pixbuf animation by loading an image from an resource.
+     *
+     * The file format is detected automatically. If `NULL` is returned, then
+     * `error` will be set.
+     * @param resourcePath - the path of the resource file
+     */
     static animationNewFromResource(resourcePath: string): PixbufAnimation;
+    /**
+     * Creates a new animation by loading it from an input stream.
+     *
+     * The file format is detected automatically.
+     *
+     * If `NULL` is returned, then `error` will be set.
+     *
+     * The `cancellable` can be used to abort the operation from another thread.
+     * If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be
+     * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and
+     * `G_IO_ERROR` domains.
+     *
+     * The stream is not closed.
+     * @param stream - a `GInputStream` to load the pixbuf from
+     * @param cancellable - optional `GCancellable` object
+     */
     static animationNewFromStream(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null): PixbufAnimation;
+    /**
+     * Finishes an asynchronous pixbuf animation creation operation started with
+     * [func@GdkPixbuf.PixbufAnimation.new_from_stream_async].
+     * @param asyncResult - a #GAsyncResult
+     */
     static animationNewFromStreamFinish(asyncResult: Gio.AsyncResult): PixbufAnimation;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Creates a new animation by asynchronously loading an image from an input stream.
+     *
+     * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
+     * version of this function.
+     *
+     * When the operation is finished, `callback` will be called in the main thread.
+     * You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
+     * result of the operation.
+     * @param stream - a #GInputStream from which to load the animation
+     * @param cancellable - optional #GCancellable object
+     * @param callback - a `GAsyncReadyCallback` to call when the pixbuf is loaded
+     * @param userData - the data to pass to the callback function
+     */
     static newFromStreamAsync(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null): void;
+    /**
+     * Queries the height of the bounding box of a pixbuf animation.
+     */
     getHeight(): number;
+    /**
+     * Get an iterator for displaying an animation.
+     *
+     * The iterator provides the frames that should be displayed at a
+     * given time.
+     *
+     * `start_time` would normally come from g_get_current_time(), and marks
+     * the beginning of animation playback. After creating an iterator, you
+     * should immediately display the pixbuf returned by
+     * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
+     * a timeout (with g_timeout_add()) or by some other mechanism ensure
+     * that you'll update the image after
+     * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
+     * the image is updated, you should reinstall the timeout with the new,
+     * possibly-changed delay time.
+     *
+     * As a shortcut, if `start_time` is `NULL`, the result of
+     * g_get_current_time() will be used automatically.
+     *
+     * To update the image (i.e. possibly change the result of
+     * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
+     * call gdk_pixbuf_animation_iter_advance().
+     *
+     * If you're using #GdkPixbufLoader, in addition to updating the image
+     * after the delay time, you should also update it whenever you
+     * receive the area_updated signal and
+     * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
+     * `TRUE`. In this case, the frame currently being fed into the loader
+     * has received new data, so needs to be refreshed. The delay time for
+     * a frame may also be modified after an area_updated signal, for
+     * example if the delay time for a frame is encoded in the data after
+     * the frame itself. So your timeout should be reinstalled after any
+     * area_updated signal.
+     *
+     * A delay time of -1 is possible, indicating "infinite".
+     * @param startTime - time when the animation starts playing
+     */
     getIter(startTime?: number | null): PixbufAnimationIter;
+    /**
+     * Retrieves a static image for the animation.
+     *
+     * If an animation is really just a plain image (has only one frame),
+     * this function returns that image.
+     *
+     * If the animation is an animation, this function returns a reasonable
+     * image to use as a static unanimated image, which might be the first
+     * frame, or something more sophisticated depending on the file format.
+     *
+     * If an animation hasn't loaded any frames yet, this function will
+     * return `NULL`.
+     */
     getStaticImage(): Pixbuf;
+    /**
+     * Queries the width of the bounding box of a pixbuf animation.
+     */
     getWidth(): number;
+    /**
+     * Checks whether the animation is a static image.
+     *
+     * If you load a file with gdk_pixbuf_animation_new_from_file() and it
+     * turns out to be a plain, unanimated image, then this function will
+     * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
+     * the image.
+     */
     isStaticImage(): boolean;
     connect(signal: "notify", handler: (self: PixbufAnimation, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;