@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gdkpixbuf/pixbuf.js

@@ -2,10 +2,159 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * A pixel buffer.
+ *
+ * `GdkPixbuf` contains information about an image's pixel data,
+ * its color space, bits per sample, width and height, and the
+ * rowstride (the number of bytes between the start of one row
+ * and the start of the next).
+ *
+ * ## Creating new `GdkPixbuf`
+ *
+ * The most basic way to create a pixbuf is to wrap an existing pixel
+ * buffer with a [class@GdkPixbuf.Pixbuf] instance. You can use the
+ * [`ctor@GdkPixbuf.Pixbuf.new_from_data`] function to do this.
+ *
+ * Every time you create a new `GdkPixbuf` instance for some data, you
+ * will need to specify the destroy notification function that will be
+ * called when the data buffer needs to be freed; this will happen when
+ * a `GdkPixbuf` is finalized by the reference counting functions. If
+ * you have a chunk of static data compiled into your application, you
+ * can pass in `NULL` as the destroy notification function so that the
+ * data will not be freed.
+ *
+ * The [`ctor@GdkPixbuf.Pixbuf.new`] constructor function can be used
+ * as a convenience to create a pixbuf with an empty buffer; this is
+ * equivalent to allocating a data buffer using `malloc()` and then
+ * wrapping it with `gdk_pixbuf_new_from_data()`. The `gdk_pixbuf_new()`
+ * function will compute an optimal rowstride so that rendering can be
+ * performed with an efficient algorithm.
+ *
+ * You can also copy an existing pixbuf with the [method@Pixbuf.copy]
+ * function. This is not the same as just acquiring a reference to
+ * the old pixbuf instance: the copy function will actually duplicate
+ * the pixel data in memory and create a new [class@Pixbuf] instance
+ * for it.
+ *
+ * ## Reference counting
+ *
+ * `GdkPixbuf` structures are reference counted. This means that an
+ * application can share a single pixbuf among many parts of the
+ * code. When a piece of the program needs to use a pixbuf, it should
+ * acquire a reference to it by calling `g_object_ref()`; when it no
+ * longer needs the pixbuf, it should release the reference it acquired
+ * by calling `g_object_unref()`. The resources associated with a
+ * `GdkPixbuf` will be freed when its reference count drops to zero.
+ * Newly-created `GdkPixbuf` instances start with a reference count
+ * of one.
+ *
+ * ## Image Data
+ *
+ * Image data in a pixbuf is stored in memory in an uncompressed,
+ * packed format. Rows in the image are stored top to bottom, and
+ * in each row pixels are stored from left to right.
+ *
+ * There may be padding at the end of a row.
+ *
+ * The "rowstride" value of a pixbuf, as returned by [`method@GdkPixbuf.Pixbuf.get_rowstride`],
+ * indicates the number of bytes between rows.
+ *
+ * **NOTE**: If you are copying raw pixbuf data with `memcpy()` note that the
+ * last row in the pixbuf may not be as wide as the full rowstride, but rather
+ * just as wide as the pixel data needs to be; that is: it is unsafe to do
+ * `memcpy (dest, pixels, rowstride * height)` to copy a whole pixbuf. Use
+ * [method@GdkPixbuf.Pixbuf.copy] instead, or compute the width in bytes of the
+ * last row as:
+ *
+ * ```c
+ * last_row = width * ((n_channels * bits_per_sample + 7) / 8);
+ * ```
+ *
+ * The same rule applies when iterating over each row of a `GdkPixbuf` pixels
+ * array.
+ *
+ * The following code illustrates a simple `put_pixel()`
+ * function for RGB pixbufs with 8 bits per channel with an alpha
+ * channel.
+ *
+ * ```c
+ * static void
+ * put_pixel (GdkPixbuf *pixbuf,
+ * int x,
+ * int y,
+ * guchar red,
+ * guchar green,
+ * guchar blue,
+ * guchar alpha)
+ * {
+ * int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
+ *
+ * // Ensure that the pixbuf is valid
+ * g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
+ * g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
+ * g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
+ * g_assert (n_channels == 4);
+ *
+ * int width = gdk_pixbuf_get_width (pixbuf);
+ * int height = gdk_pixbuf_get_height (pixbuf);
+ *
+ * // Ensure that the coordinates are in a valid range
+ * g_assert (x >= 0 && x < width);
+ * g_assert (y >= 0 && y < height);
+ *
+ * int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ *
+ * // The pixel buffer in the GdkPixbuf instance
+ * guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
+ *
+ * // The pixel we wish to modify
+ * guchar *p = pixels + y * rowstride + x * n_channels;
+ * p[0] = red;
+ * p[1] = green;
+ * p[2] = blue;
+ * p[3] = alpha;
+ * }
+ * ```
+ *
+ * ## Loading images
+ *
+ * The `GdkPixBuf` class provides a simple mechanism for loading
+ * an image from a file in synchronous and asynchronous fashion.
+ *
+ * For GUI applications, it is recommended to use the asynchronous
+ * stream API to avoid blocking the control flow of the application.
+ *
+ * Additionally, `GdkPixbuf` provides the [class@GdkPixbuf.PixbufLoader`]
+ * API for progressive image loading.
+ *
+ * ## Saving images
+ *
+ * The `GdkPixbuf` class provides methods for saving image data in
+ * a number of file formats. The formatted data can be written to a
+ * file or to a memory buffer. `GdkPixbuf` can also call a user-defined
+ * callback on the data, which allows to e.g. write the image
+ * to a socket or store it in a database.
+ */
 export class Pixbuf extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new #GdkPixbuf out of in-memory readonly image data.
+     *
+     * Currently only RGB images with 8 bits per sample are supported.
+     *
+     * This is the `GBytes` variant of gdk_pixbuf_new_from_data(), useful
+     * for language bindings.
+     * @param data - Image data in 8-bit/sample packed format inside a #GBytes
+     * @param colorspace - Colorspace for the image data
+     * @param hasAlpha - Whether the data has an opacity channel
+     * @param bitsPerSample - Number of bits per sample
+     * @param width - Width of the image in pixels, must be > 0
+     * @param height - Height of the image in pixels, must be > 0
+     * @param rowstride - Distance in bytes between row starts
+     */
     static newFromBytes(data, colorspace, hasAlpha, bitsPerSample, width, height, rowstride) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_bytes", [
             {
@@ -44,6 +193,28 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new #GdkPixbuf out of in-memory image data.
+     *
+     * Currently only RGB images with 8 bits per sample are supported.
+     *
+     * Since you are providing a pre-allocated pixel buffer, you must also
+     * specify a way to free that data.  This is done with a function of
+     * type `GdkPixbufDestroyNotify`.  When a pixbuf created with is
+     * finalized, your destroy notification function will be called, and
+     * it is its responsibility to free the pixel array.
+     *
+     * See also: [ctor@GdkPixbuf.Pixbuf.new_from_bytes]
+     * @param data - Image data in 8-bit/sample packed format
+     * @param colorspace - Colorspace for the image data
+     * @param hasAlpha - Whether the data has an opacity channel
+     * @param bitsPerSample - Number of bits per sample
+     * @param width - Width of the image in pixels, must be > 0
+     * @param height - Height of the image in pixels, must be > 0
+     * @param rowstride - Distance in bytes between row starts
+     * @param destroyFn - Function
+     * @param destroyFnData - Closure data to pass to the destroy
+     */
     static newFromData(data, colorspace, hasAlpha, bitsPerSample, width, height, rowstride, destroyFn, destroyFnData) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_data", [
             {
@@ -90,6 +261,21 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by loading an image from a file.
+     *
+     * The file format is detected automatically.
+     *
+     * If `NULL` is returned, then `error` will be set. Possible errors are:
+     *
+     * - the file could not be opened
+     * - there is no loader for the file's format
+     * - there is not enough memory to allocate the image buffer
+     * - the image buffer contains invalid data
+     *
+     * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
+     * @param filename - Name of file to load, in the GLib file
+     */
     static newFromFile(filename) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_file", [
             {
@@ -99,6 +285,34 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by loading an image from a file.
+     *
+     * The file format is detected automatically.
+     *
+     * If `NULL` is returned, then `error` will be set. Possible errors are:
+     *
+     * - the file could not be opened
+     * - there is no loader for the file's format
+     * - there is not enough memory to allocate the image buffer
+     * - the image buffer contains invalid data
+     *
+     * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
+     *
+     * The image will be scaled to fit in the requested size, optionally preserving
+     * the image's aspect ratio.
+     *
+     * When preserving the aspect ratio, a `width` of -1 will cause the image
+     * to be scaled to the exact given height, and a `height` of -1 will cause
+     * the image to be scaled to the exact given width. When not preserving
+     * aspect ratio, a `width` or `height` of -1 means to not scale the image
+     * at all in that dimension. Negative values for `width` and `height` are
+     * allowed since 2.8.
+     * @param filename - Name of file to load, in the GLib file
+     * @param width - The width the image should have or -1 to not constrain the width
+     * @param height - The height the image should have or -1 to not constrain the height
+     * @param preserveAspectRatio - `TRUE` to preserve the image's aspect ratio
+     */
     static newFromFileAtScale(filename, width, height, preserveAspectRatio) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_file_at_scale", [
             {
@@ -120,6 +334,29 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by loading an image from a file.
+     *
+     * The file format is detected automatically.
+     *
+     * If `NULL` is returned, then `error` will be set. Possible errors are:
+     *
+     * - the file could not be opened
+     * - there is no loader for the file's format
+     * - there is not enough memory to allocate the image buffer
+     * - the image buffer contains invalid data
+     *
+     * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
+     *
+     * The image will be scaled to fit in the requested size, preserving
+     * the image's aspect ratio. Note that the returned pixbuf may be smaller
+     * than `width` x `height`, if the aspect ratio requires it. To load
+     * and image at the requested size, regardless of aspect ratio, use
+     * [ctor@GdkPixbuf.Pixbuf.new_from_file_at_scale].
+     * @param filename - Name of file to load, in the GLib file
+     * @param width - The width the image should have or -1 to not constrain the width
+     * @param height - The height the image should have or -1 to not constrain the height
+     */
     static newFromFileAtSize(filename, width, height) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_file_at_size", [
             {
@@ -137,6 +374,44 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a `GdkPixbuf` from a flat representation that is suitable for
+     * storing as inline data in a program.
+     *
+     * This is useful if you want to ship a program with images, but don't want
+     * to depend on any external files.
+     *
+     * GdkPixbuf ships with a program called `gdk-pixbuf-csource`, which allows
+     * for conversion of `GdkPixbuf`s into such a inline representation.
+     *
+     * In almost all cases, you should pass the `--raw` option to
+     * `gdk-pixbuf-csource`. A sample invocation would be:
+     *
+     * ```
+     * gdk-pixbuf-csource --raw --name=myimage_inline myimage.png
+     * ```
+     *
+     * For the typical case where the inline pixbuf is read-only static data,
+     * you don't need to copy the pixel data unless you intend to write to
+     * it, so you can pass `FALSE` for `copy_pixels`. If you pass `--rle` to
+     * `gdk-pixbuf-csource`, a copy will be made even if `copy_pixels` is `FALSE`,
+     * so using this option is generally a bad idea.
+     *
+     * If you create a pixbuf from const inline data compiled into your
+     * program, it's probably safe to ignore errors and disable length checks,
+     * since things will always succeed:
+     *
+     * ```c
+     * pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL);
+     * ```
+     *
+     * For non-const inline data, you could get out of memory. For untrusted
+     * inline data located at runtime, you could have corrupt inline data in
+     * addition.
+     * @param dataLength - Length in bytes of the `data` argument or -1 to
+     * @param data - Byte data containing a
+     * @param copyPixels - Whether to copy the pixel data, or use direct pointers
+     */
     static newFromInline(dataLength, data, copyPixels) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_inline", [
             {
@@ -157,6 +432,13 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf 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 newFromResource(resourcePath) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_resource", [
             {
@@ -166,6 +448,25 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by loading an image from an resource.
+     *
+     * The file format is detected automatically. If `NULL` is returned, then
+     * `error` will be set.
+     *
+     * The image will be scaled to fit in the requested size, optionally
+     * preserving the image's aspect ratio. When preserving the aspect ratio,
+     * a `width` of -1 will cause the image to be scaled to the exact given
+     * height, and a `height` of -1 will cause the image to be scaled to the
+     * exact given width. When not preserving aspect ratio, a `width` or
+     * `height` of -1 means to not scale the image at all in that dimension.
+     *
+     * The stream is not closed.
+     * @param resourcePath - the path of the resource file
+     * @param width - The width the image should have or -1 to not constrain the width
+     * @param height - The height the image should have or -1 to not constrain the height
+     * @param preserveAspectRatio - `TRUE` to preserve the image's aspect ratio
+     */
     static newFromResourceAtScale(resourcePath, width, height, preserveAspectRatio) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_resource_at_scale", [
             {
@@ -187,6 +488,22 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by loading an image 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, `NULL` to ignore
+     */
     static newFromStream(stream, cancellable) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream", [
             {
@@ -201,6 +518,34 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by loading an image 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 image will be scaled to fit in the requested size, optionally
+     * preserving the image's aspect ratio.
+     *
+     * When preserving the aspect ratio, a `width` of -1 will cause the image to be
+     * scaled to the exact given height, and a `height` of -1 will cause the image
+     * to be scaled to the exact given width. If both `width` and `height` are
+     * given, this function will behave as if the smaller of the two values
+     * is passed as -1.
+     *
+     * When not preserving aspect ratio, a `width` or `height` of -1 means to not
+     * scale the image at all in that dimension.
+     *
+     * The stream is not closed.
+     * @param stream - a `GInputStream` to load the pixbuf from
+     * @param width - The width the image should have or -1 to not constrain the width
+     * @param height - The height the image should have or -1 to not constrain the height
+     * @param preserveAspectRatio - `TRUE` to preserve the image's aspect ratio
+     * @param cancellable - optional `GCancellable` object, `NULL` to ignore
+     */
     static newFromStreamAtScale(stream, width, height, preserveAspectRatio, cancellable) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream_at_scale", [
             {
@@ -227,6 +572,11 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Finishes an asynchronous pixbuf creation operation started with
+     * gdk_pixbuf_new_from_stream_async().
+     * @param asyncResult - a `GAsyncResult`
+     */
     static newFromStreamFinish(asyncResult) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream_finish", [
             {
@@ -236,6 +586,13 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new pixbuf by parsing XPM data in memory.
+     *
+     * This data is commonly the result of including an XPM file into a
+     * program's C source.
+     * @param data - Pointer to inline XPM data.
+     */
     static newFromXpmData(data) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_xpm_data", [
             {
@@ -270,6 +627,18 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Calculates the rowstride that an image created with those values would
+     * have.
+     *
+     * This function is useful for front-ends and backends that want to check
+     * image values without needing to create a `GdkPixbuf`.
+     * @param colorspace - Color space for image
+     * @param hasAlpha - Whether the image should have transparency information
+     * @param bitsPerSample - Number of bits per color sample
+     * @param width - Width of image in pixels, must be > 0
+     * @param height - Height of image in pixels, must be > 0
+     */
     static calculateRowstride(colorspace, hasAlpha, bitsPerSample, width, height) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_calculate_rowstride", [
             {
@@ -294,6 +663,12 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Parses an image file far enough to determine its format and size.
+     * @param filename - The name of the file to identify.
+     * @param width - Return location for the width of the image
+     * @param height - Return location for the height of the image
+     */
     static getFileInfo(filename, width, height) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_file_info", [
             {
@@ -323,6 +698,21 @@ export class Pixbuf extends GObject.GObject {
             lib: "libgdk_pixbuf-2.0.so.0",
         });
     }
+    /**
+     * Asynchronously parses an image file far enough to determine its
+     * format and size.
+     *
+     * For more details see gdk_pixbuf_get_file_info(), 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_get_file_info_finish() to
+     * get the result of the operation.
+     * @param filename - The name of the file to identify
+     * @param cancellable - optional `GCancellable` object, `NULL` to ignore
+     * @param callback - a `GAsyncReadyCallback` to call when the file info is available
+     * @param userData - the data to pass to the callback function
+     */
     static getFileInfoAsync(filename, cancellable, callback) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_file_info_async", [
             {
@@ -346,6 +736,13 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an asynchronous pixbuf parsing operation started with
+     * gdk_pixbuf_get_file_info_async().
+     * @param asyncResult - a `GAsyncResult`
+     * @param width - Return location for the width of the image, or `NULL`
+     * @param height - Return location for the height of the image, or `NULL`
+     */
     static getFileInfoFinish(asyncResult, width, height) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_file_info_finish", [
@@ -389,6 +786,10 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Obtains the available information about the image formats supported
+     * by GdkPixbuf.
+     */
     static getFormats() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_formats", [], {
             type: "array",
@@ -401,6 +802,22 @@ export class Pixbuf extends GObject.GObject {
             borrowed: true,
         });
     }
+    /**
+     * Initalizes the gdk-pixbuf loader modules referenced by the `loaders.cache`
+     * file present inside that directory.
+     *
+     * This is to be used by applications that want to ship certain loaders
+     * in a different location from the system ones.
+     *
+     * This is needed when the OS or runtime ships a minimal number of loaders
+     * so as to reduce the potential attack surface of carefully crafted image
+     * files, especially for uncommon file types. Applications that require
+     * broader image file types coverage, such as image viewers, would be
+     * expected to ship the gdk-pixbuf modules in a separate location, bundled
+     * with the application in a separate directory from the OS or runtime-
+     * provided modules.
+     * @param path - Path to directory where the `loaders.cache` is installed
+     */
     static initModules(path) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_init_modules", [
@@ -425,6 +842,20 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Creates a new pixbuf 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_new_from_stream_finish() to get the result of
+     * the operation.
+     * @param stream - a `GInputStream` from which to load the pixbuf
+     * @param cancellable - optional `GCancellable` object, `NULL` to ignore
+     * @param callback - a `GAsyncReadyCallback` to call when the pixbuf is loaded
+     * @param userData - the data to pass to the callback function
+     */
     static newFromStreamAsync(stream, cancellable, callback) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream_async", [
             {
@@ -448,6 +879,22 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a new pixbuf by asynchronously loading an image from an input stream.
+     *
+     * For more details see gdk_pixbuf_new_from_stream_at_scale(), 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_new_from_stream_finish() to get the result of the operation.
+     * @param stream - a `GInputStream` from which to load the pixbuf
+     * @param width - the width the image should have or -1 to not constrain the width
+     * @param height - the height the image should have or -1 to not constrain the height
+     * @param preserveAspectRatio - `TRUE` to preserve the image's aspect ratio
+     * @param cancellable - optional `GCancellable` object, `NULL` to ignore
+     * @param callback - a `GAsyncReadyCallback` to call when the pixbuf is loaded
+     * @param userData - the data to pass to the callback function
+     */
     static newFromStreamAtScaleAsync(stream, width, height, preserveAspectRatio, cancellable, callback) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream_at_scale_async", [
             {
@@ -483,6 +930,11 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an asynchronous pixbuf save operation started with
+     * gdk_pixbuf_save_to_stream_async().
+     * @param asyncResult - a `GAsyncResult`
+     */
     static saveToStreamFinish(asyncResult) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_save_to_stream_finish", [
@@ -507,6 +959,25 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Takes an existing pixbuf and adds an alpha channel to it.
+     *
+     * If the existing pixbuf already had an alpha channel, the channel
+     * values are copied from the original; otherwise, the alpha channel
+     * is initialized to 255 (full opacity).
+     *
+     * If `substitute_color` is `TRUE`, then the color specified by the
+     * (`r`, `g`, `b`) arguments will be assigned zero opacity. That is,
+     * if you pass `(255, 255, 255)` for the substitute color, all white
+     * pixels will become fully transparent.
+     *
+     * If `substitute_color` is `FALSE`, then the (`r`, `g`, `b`) arguments
+     * will be ignored.
+     * @param substituteColor - Whether to set a color to zero opacity.
+     * @param r - Red value to substitute.
+     * @param g - Green value to substitute.
+     * @param b - Blue value to substitute.
+     */
     addAlpha(substituteColor, r, g, b) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_add_alpha", [
             {
@@ -534,6 +1005,18 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Takes an existing pixbuf and checks for the presence of an
+     * associated "orientation" option.
+     *
+     * The orientation option may be provided by the JPEG loader (which
+     * reads the exif orientation tag) or the TIFF loader (which reads
+     * the TIFF orientation tag, and compensates it for the partial
+     * transforms performed by libtiff).
+     *
+     * If an orientation option/tag is present, the appropriate transform
+     * will be performed so that the pixbuf is oriented correctly.
+     */
     applyEmbeddedOrientation() {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_apply_embedded_orientation", [
             {
@@ -545,6 +1028,30 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a transformation of the source image `src` by scaling by
+     * `scale_x` and `scale_y` then translating by `offset_x` and @offset_y.
+     *
+     * This gives an image in the coordinates of the destination pixbuf.
+     * The rectangle (@dest_x, @dest_y, @dest_width, @dest_height)
+     * is then alpha blended onto the corresponding rectangle of the
+     * original destination image.
+     *
+     * When the destination rectangle contains parts not in the source
+     * image, the data at the edges of the source image is replicated
+     * to infinity.
+     * @param dest - the #GdkPixbuf into which to render the results
+     * @param destX - the left coordinate for region to render
+     * @param destY - the top coordinate for region to render
+     * @param destWidth - the width of the region to render
+     * @param destHeight - the height of the region to render
+     * @param offsetX - the offset in the X direction (currently rounded to an integer)
+     * @param offsetY - the offset in the Y direction (currently rounded to an integer)
+     * @param scaleX - the scale factor in the X direction
+     * @param scaleY - the scale factor in the Y direction
+     * @param interpType - the interpolation type for the transformation.
+     * @param overallAlpha - overall alpha for source image (0..255)
+     */
     composite(dest, destX, destY, destWidth, destHeight, offsetX, offsetY, scaleX, scaleY, interpType, overallAlpha) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_composite", [
             {
@@ -597,6 +1104,36 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a transformation of the source image `src` by scaling by
+     * `scale_x` and `scale_y` then translating by `offset_x` and @offset_y,
+     * then alpha blends the rectangle (`dest_x` ,@dest_y, @dest_width,
+     * @dest_height) of the resulting image with a checkboard of the
+     * colors `color1` and `color2` and renders it onto the destination
+     * image.
+     *
+     * If the source image has no alpha channel, and `overall_alpha` is 255, a fast
+     * path is used which omits the alpha blending and just performs the scaling.
+     *
+     * See gdk_pixbuf_composite_color_simple() for a simpler variant of this
+     * function suitable for many tasks.
+     * @param dest - the #GdkPixbuf into which to render the results
+     * @param destX - the left coordinate for region to render
+     * @param destY - the top coordinate for region to render
+     * @param destWidth - the width of the region to render
+     * @param destHeight - the height of the region to render
+     * @param offsetX - the offset in the X direction (currently rounded to an integer)
+     * @param offsetY - the offset in the Y direction (currently rounded to an integer)
+     * @param scaleX - the scale factor in the X direction
+     * @param scaleY - the scale factor in the Y direction
+     * @param interpType - the interpolation type for the transformation.
+     * @param overallAlpha - overall alpha for source image (0..255)
+     * @param checkX - the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)
+     * @param checkY - the Y offset for the checkboard
+     * @param checkSize - the size of checks in the checkboard (must be a power of two)
+     * @param color1 - the color of check at upper left
+     * @param color2 - the color of the other check
+     */
     compositeColor(dest, destX, destY, destWidth, destHeight, offsetX, offsetY, scaleX, scaleY, interpType, overallAlpha, checkX, checkY, checkSize, color1, color2) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_composite_color", [
             {
@@ -669,6 +1206,18 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a new pixbuf by scaling `src` to `dest_width` x `dest_height`
+     * and alpha blending the result with a checkboard of colors `color1`
+     * and `color2`.
+     * @param destWidth - the width of destination image
+     * @param destHeight - the height of destination image
+     * @param interpType - the interpolation type for the transformation.
+     * @param overallAlpha - overall alpha for source image (0..255)
+     * @param checkSize - the size of checks in the checkboard (must be a power of two)
+     * @param color1 - the color of check at upper left
+     * @param color2 - the color of the other check
+     */
     compositeColorSimple(destWidth, destHeight, interpType, overallAlpha, checkSize, color1, color2) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_composite_color_simple", [
             {
@@ -708,6 +1257,13 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Creates a new `GdkPixbuf` with a copy of the information in the specified
+     * `pixbuf`.
+     *
+     * Note that this does not copy the options set on the original `GdkPixbuf`,
+     * use gdk_pixbuf_copy_options() for this.
+     */
     copy() {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_copy", [
             {
@@ -719,6 +1275,22 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Copies a rectangular area from `src_pixbuf` to `dest_pixbuf`.
+     *
+     * Conversion of pixbuf formats is done automatically.
+     *
+     * If the source rectangle overlaps the destination rectangle on the
+     * same pixbuf, it will be overwritten during the copy operation.
+     * Therefore, you can not use this function to scroll a pixbuf.
+     * @param srcX - Source X coordinate within @src_pixbuf.
+     * @param srcY - Source Y coordinate within @src_pixbuf.
+     * @param width - Width of the area to copy.
+     * @param height - Height of the area to copy.
+     * @param destPixbuf - Destination pixbuf.
+     * @param destX - X coordinate within @dest_pixbuf.
+     * @param destY - Y coordinate within @dest_pixbuf.
+     */
     copyArea(srcX, srcY, width, height, destPixbuf, destX, destY) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_copy_area", [
             {
@@ -755,6 +1327,15 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Copies the key/value pair options attached to a `GdkPixbuf` to another
+     * `GdkPixbuf`.
+     *
+     * This is useful to keep original metadata after having manipulated
+     * a file. However be careful to remove metadata which you've already
+     * applied, such as the "orientation" option after rotating the image.
+     * @param destPixbuf - the destination pixbuf
+     */
     copyOptions(destPixbuf) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_copy_options", [
             {
@@ -767,6 +1348,14 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Clears a pixbuf to the given RGBA value, converting the RGBA value into
+     * the pixbuf's pixel format.
+     *
+     * The alpha component will be ignored if the pixbuf doesn't have an alpha
+     * channel.
+     * @param pixel - RGBA pixel to used to clear (`0xffffffff` is opaque white,
+     */
     fill(pixel) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_fill", [
             {
@@ -779,6 +1368,11 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Flips a pixbuf horizontally or vertically and returns the
+     * result in a new pixbuf.
+     * @param horizontal - `TRUE` to flip horizontally, `FALSE` to flip vertically
+     */
     flip(horizontal) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_flip", [
             {
@@ -794,6 +1388,9 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Queries the number of bits per color sample in a pixbuf.
+     */
     getBitsPerSample() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_bits_per_sample", [
             {
@@ -802,6 +1399,9 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the length of the pixel data, in bytes.
+     */
     getByteLength() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_byte_length", [
             {
@@ -810,6 +1410,9 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Queries the color space of a pixbuf.
+     */
     getColorspace() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_colorspace", [
             {
@@ -818,6 +1421,9 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Queries whether a pixbuf has an alpha channel (opacity information).
+     */
     getHasAlpha() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_has_alpha", [
             {
@@ -826,6 +1432,9 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Queries the height of a pixbuf.
+     */
     getHeight() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_height", [
             {
@@ -834,6 +1443,9 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Queries the number of channels of a pixbuf.
+     */
     getNChannels() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_n_channels", [
             {
@@ -842,6 +1454,24 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Looks up `key` in the list of options that may have been attached to the
+     * `pixbuf` when it was loaded, or that may have been attached by another
+     * function using gdk_pixbuf_set_option().
+     *
+     * For instance, the ANI loader provides "Title" and "Artist" options.
+     * The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot
+     * options for cursor definitions. The PNG loader provides the tEXt ancillary
+     * chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders
+     * return an "orientation" option string that corresponds to the embedded
+     * TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets
+     * the "multipage" option string to "yes" when a multi-page TIFF is loaded.
+     * Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file
+     * contains image density information in dots per inch.
+     * Since 2.36.6, the JPEG loader sets the "comment" option with the comment
+     * EXIF tag.
+     * @param key - a nul-terminated string.
+     */
     getOption(key) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_option", [
             {
@@ -854,6 +1484,11 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns a `GHashTable` with a list of all the options that may have been
+     * attached to the `pixbuf` when it was loaded, or that may have been
+     * attached by another function using [method@GdkPixbuf.Pixbuf.set_option].
+     */
     getOptions() {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_options", [
             {
@@ -868,6 +1503,15 @@ export class Pixbuf extends GObject.GObject {
         });
         return getObject(ptr, GLib.HashTable);
     }
+    /**
+     * Queries a pointer to the pixel data of a pixbuf.
+     *
+     * This function will cause an implicit copy of the pixbuf data if the
+     * pixbuf was created from read-only data.
+     *
+     * Please see the section on image data for information
+     * about how the pixel data is stored in memory.
+     */
     getPixels() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_pixels", [
             {
@@ -876,6 +1520,16 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
     }
+    /**
+     * Queries a pointer to the pixel data of a pixbuf.
+     *
+     * This function will cause an implicit copy of the pixbuf data if the
+     * pixbuf was created from read-only data.
+     *
+     * Please see the section on image data for information
+     * about how the pixel data is stored in memory.
+     * @param length - The length of the binary data.
+     */
     getPixelsWithLength(length) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_pixels_with_length", [
             {
@@ -891,6 +1545,10 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
     }
+    /**
+     * Queries the rowstride of a pixbuf, which is the number of bytes between
+     * the start of a row and the start of the next row.
+     */
     getRowstride() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_rowstride", [
             {
@@ -899,6 +1557,9 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Queries the width of a pixbuf.
+     */
     getWidth() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_width", [
             {
@@ -907,6 +1568,21 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Creates a new pixbuf which represents a sub-region of `src_pixbuf`.
+     *
+     * The new pixbuf shares its pixels with the original pixbuf, so
+     * writing to one affects both.  The new pixbuf holds a reference to
+     * `src_pixbuf`, so `src_pixbuf` will not be finalized until the new
+     * pixbuf is finalized.
+     *
+     * Note that if `src_pixbuf` is read-only, this function will force it
+     * to be mutable.
+     * @param srcX - X coord in @src_pixbuf
+     * @param srcY - Y coord in @src_pixbuf
+     * @param width - width of region in @src_pixbuf
+     * @param height - height of region in @src_pixbuf
+     */
     newSubpixbuf(srcX, srcY, width, height) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_subpixbuf", [
             {
@@ -932,6 +1608,13 @@ export class Pixbuf extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Provides a #GBytes buffer containing the raw pixel data; the data
+     * must not be modified.
+     *
+     * This function allows skipping the implicit copy that must be made
+     * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
+     */
     readPixelBytes() {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_read_pixel_bytes", [
             {
@@ -946,6 +1629,12 @@ export class Pixbuf extends GObject.GObject {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * Provides a read-only pointer to the raw pixel data.
+     *
+     * This function allows skipping the implicit copy that must be made
+     * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
+     */
     readPixels() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_read_pixels", [
             {
@@ -954,6 +1643,10 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "int", size: 8, unsigned: true });
     }
+    /**
+     * Removes the key/value pair option attached to a `GdkPixbuf`.
+     * @param key - a nul-terminated string representing the key to remove.
+     */
     removeOption(key) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_remove_option", [
             {
@@ -966,6 +1659,13 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Rotates a pixbuf by a multiple of 90 degrees, and returns the
+     * result in a new pixbuf.
+     *
+     * If `angle` is 0, this function will return a copy of `src`.
+     * @param angle - the angle to rotate by
+     */
     rotateSimple(angle) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_rotate_simple", [
             {
@@ -981,6 +1681,25 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Modifies saturation and optionally pixelates `src`, placing the result in
+     * `dest`.
+     *
+     * The `src` and `dest` pixbufs must have the same image format, size, and
+     * rowstride.
+     *
+     * The `src` and `dest` arguments may be the same pixbuf with no ill effects.
+     *
+     * If `saturation` is 1.0 then saturation is not changed. If it's less than 1.0,
+     * saturation is reduced (the image turns toward grayscale); if greater than
+     * 1.0, saturation is increased (the image gets more vivid colors).
+     *
+     * If `pixelate` is `TRUE`, then pixels are faded in a checkerboard pattern to
+     * create a pixelated image.
+     * @param dest - place to write modified version of @src
+     * @param saturation - saturation factor
+     * @param pixelate - whether to pixelate
+     */
     saturateAndPixelate(dest, saturation, pixelate) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_saturate_and_pixelate", [
             {
@@ -1001,6 +1720,19 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Vector version of `gdk_pixbuf_save_to_buffer()`.
+     *
+     * Saves pixbuf to a new buffer in format @type, which is currently "jpeg",
+     * "tiff", "png", "ico" or "bmp".
+     *
+     * See [method@GdkPixbuf.Pixbuf.save_to_buffer] for more details.
+     * @param buffer - location to receive a pointer to the new buffer.
+     * @param bufferSize - location to receive the size of the new buffer.
+     * @param type - name of file format.
+     * @param optionKeys - name of options to set
+     * @param optionValues - values for named options
+     */
     saveToBufferv(buffer, bufferSize, type, optionKeys, optionValues) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_save_to_bufferv", [
@@ -1056,6 +1788,21 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Vector version of `gdk_pixbuf_save_to_callback()`.
+     *
+     * Saves pixbuf to a callback in format @type, which is currently "jpeg",
+     * "png", "tiff", "ico" or "bmp".
+     *
+     * If `error` is set, `FALSE` will be returned.
+     *
+     * See [method@GdkPixbuf.Pixbuf.save_to_callback] for more details.
+     * @param saveFunc - a function that is called to
+     * @param userData - user data to pass to the save function
+     * @param type - name of file format
+     * @param optionKeys - name of options to set
+     * @param optionValues - values for named options
+     */
     saveToCallbackv(saveFunc, type, userData, optionKeys, optionValues) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_save_to_callbackv", [
@@ -1103,6 +1850,19 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Saves `pixbuf` to an output stream.
+     *
+     * Supported file formats are currently "jpeg", "tiff", "png", "ico" or
+     * "bmp".
+     *
+     * See [method@GdkPixbuf.Pixbuf.save_to_stream] for more details.
+     * @param stream - a `GOutputStream` to save the pixbuf to
+     * @param type - name of file format
+     * @param optionKeys - name of options to set
+     * @param optionValues - values for named options
+     * @param cancellable - optional `GCancellable` object, `NULL` to ignore
+     */
     saveToStreamv(stream, type, optionKeys, optionValues, cancellable) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_save_to_streamv", [
@@ -1150,6 +1910,19 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Vector version of `gdk_pixbuf_save()`.
+     *
+     * Saves pixbuf to a file in `type`, which is currently "jpeg", "png", "tiff", "ico" or "bmp".
+     *
+     * If `error` is set, `FALSE` will be returned.
+     *
+     * See [method@GdkPixbuf.Pixbuf.save] for more details.
+     * @param filename - name of file to save.
+     * @param type - name of file format.
+     * @param optionKeys - name of options to set
+     * @param optionValues - values for named options
+     */
     savev(filename, type, optionKeys, optionValues) {
         const error = { value: null };
         const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_savev", [
@@ -1192,6 +1965,31 @@ export class Pixbuf extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Creates a transformation of the source image `src` by scaling by
+     * `scale_x` and `scale_y` then translating by `offset_x` and @offset_y,
+     * then renders the rectangle (@dest_x, @dest_y, @dest_width,
+     * @dest_height) of the resulting image onto the destination image
+     * replacing the previous contents.
+     *
+     * Try to use gdk_pixbuf_scale_simple() first; this function is
+     * the industrial-strength power tool you can fall back to, if
+     * gdk_pixbuf_scale_simple() isn't powerful enough.
+     *
+     * If the source rectangle overlaps the destination rectangle on the
+     * same pixbuf, it will be overwritten during the scaling which
+     * results in rendering artifacts.
+     * @param dest - the #GdkPixbuf into which to render the results
+     * @param destX - the left coordinate for region to render
+     * @param destY - the top coordinate for region to render
+     * @param destWidth - the width of the region to render
+     * @param destHeight - the height of the region to render
+     * @param offsetX - the offset in the X direction (currently rounded to an integer)
+     * @param offsetY - the offset in the Y direction (currently rounded to an integer)
+     * @param scaleX - the scale factor in the X direction
+     * @param scaleY - the scale factor in the Y direction
+     * @param interpType - the interpolation type for the transformation.
+     */
     scale(dest, destX, destY, destWidth, destHeight, offsetX, offsetY, scaleX, scaleY, interpType) {
         call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_scale", [
             {
@@ -1240,6 +2038,29 @@ export class Pixbuf extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Create a new pixbuf containing a copy of `src` scaled to
+     * `dest_width` x `dest_height`.
+     *
+     * This function leaves `src` unaffected.
+     *
+     * The `interp_type` should be `GDK_INTERP_NEAREST` if you want maximum
+     * speed (but when scaling down `GDK_INTERP_NEAREST` is usually unusably
+     * ugly). The default `interp_type` should be `GDK_INTERP_BILINEAR` which
+     * offers reasonable quality and speed.
+     *
+     * You can scale a sub-portion of `src` by creating a sub-pixbuf
+     * pointing into `src`; see [method@GdkPixbuf.Pixbuf.new_subpixbuf].
+     *
+     * If `dest_width` and `dest_height` are equal to the width and height of
+     * `src`, this function will return an unscaled copy of `src`.
+     *
+     * For more complicated scaling/alpha blending see [method@GdkPixbuf.Pixbuf.scale]
+     * and [method@GdkPixbuf.Pixbuf.composite].
+     * @param destWidth - the width of destination image
+     * @param destHeight - the height of destination image
+     * @param interpType - the interpolation type for the transformation.
+     */
     scaleSimple(destWidth, destHeight, interpType) {
         const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_scale_simple", [
             {
@@ -1263,6 +2084,14 @@ export class Pixbuf extends GObject.GObject {
             return null;
         return getObject(ptr, Pixbuf);
     }
+    /**
+     * Attaches a key/value pair as an option to a `GdkPixbuf`.
+     *
+     * If `key` already exists in the list of options attached to the `pixbuf`,
+     * the new value is ignored and `FALSE` is returned.
+     * @param key - a nul-terminated string.
+     * @param value - a nul-terminated string.
+     */
     setOption(key, value) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_set_option", [
             {