@gtkx/ffi 0.1.45 → 0.1.47

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

@@ -4,65 +4,907 @@ import { PixbufFormat } from "./pixbuf-format.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/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 declare class Pixbuf extends GObject.GObject {
+    /**
+     * Creates a new `GdkPixbuf` structure and allocates a buffer for it.
+     *
+     * If the allocation of the buffer failed, this function will return `NULL`.
+     *
+     * The buffer has an optimal rowstride. Note that the buffer is not cleared;
+     * you will have to fill it completely yourself.
+     * @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
+     */
     constructor(colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number);
     constructor(...args: unknown[]);
+    /**
+     * 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: GLib.Bytes, colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number): 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: number[], colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number, destroyFn?: (...args: unknown[]) => unknown | null, destroyFnData?: number | null): 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: string): 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: string, width: number, height: number, preserveAspectRatio: boolean): 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: string, width: number, height: number): 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: number, data: number[], copyPixels: boolean): 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: string): 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: string, width: number, height: number, preserveAspectRatio: boolean): 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: Gio.InputStream, cancellable?: Gio.Cancellable | null): 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: Gio.InputStream, width: number, height: number, preserveAspectRatio: boolean, cancellable?: Gio.Cancellable | null): Pixbuf;
+    /**
+     * Finishes an asynchronous pixbuf creation operation started with
+     * gdk_pixbuf_new_from_stream_async().
+     * @param asyncResult - a `GAsyncResult`
+     */
     static newFromStreamFinish(asyncResult: Gio.AsyncResult): 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: string[]): Pixbuf;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * 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: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number): number;
+    /**
+     * 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: string, width?: Ref<number> | null, height?: Ref<number> | null): PixbufFormat;
+    /**
+     * 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: string, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null): void;
+    /**
+     * 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: Gio.AsyncResult, width: Ref<number>, height: Ref<number>): PixbufFormat;
+    /**
+     * Obtains the available information about the image formats supported
+     * by GdkPixbuf.
+     */
     static getFormats(): PixbufFormat[];
+    /**
+     * 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: string): boolean;
+    /**
+     * 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: Gio.InputStream, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null): void;
+    /**
+     * 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: Gio.InputStream, width: number, height: number, preserveAspectRatio: boolean, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null): void;
+    /**
+     * Finishes an asynchronous pixbuf save operation started with
+     * gdk_pixbuf_save_to_stream_async().
+     * @param asyncResult - a `GAsyncResult`
+     */
     static saveToStreamFinish(asyncResult: Gio.AsyncResult): boolean;
+    /**
+     * 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: boolean, r: number, g: number, b: number): Pixbuf | null;
+    /**
+     * 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(): Pixbuf | null;
+    /**
+     * 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: Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: InterpType, overallAlpha: number): void;
+    /**
+     * 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: Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: InterpType, overallAlpha: number, checkX: number, checkY: number, checkSize: number, color1: number, color2: number): void;
+    /**
+     * 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: number, destHeight: number, interpType: InterpType, overallAlpha: number, checkSize: number, color1: number, color2: number): Pixbuf | null;
+    /**
+     * 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(): Pixbuf | null;
+    /**
+     * 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: number, srcY: number, width: number, height: number, destPixbuf: Pixbuf, destX: number, destY: number): void;
+    /**
+     * 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: Pixbuf): 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: number): void;
+    /**
+     * 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: boolean): Pixbuf | null;
+    /**
+     * Queries the number of bits per color sample in a pixbuf.
+     */
     getBitsPerSample(): number;
+    /**
+     * Returns the length of the pixel data, in bytes.
+     */
     getByteLength(): number;
+    /**
+     * Queries the color space of a pixbuf.
+     */
     getColorspace(): Colorspace;
+    /**
+     * Queries whether a pixbuf has an alpha channel (opacity information).
+     */
     getHasAlpha(): boolean;
+    /**
+     * Queries the height of a pixbuf.
+     */
     getHeight(): number;
+    /**
+     * Queries the number of channels of a pixbuf.
+     */
     getNChannels(): number;
+    /**
+     * 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: string): string | null;
+    /**
+     * 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(): 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(): number[];
+    /**
+     * 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: Ref<number>): number[];
+    /**
+     * 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(): number;
+    /**
+     * Queries the width of a pixbuf.
+     */
     getWidth(): number;
+    /**
+     * 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: number, srcY: number, width: number, height: number): 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(): 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(): number;
+    /**
+     * Removes the key/value pair option attached to a `GdkPixbuf`.
+     * @param key - a nul-terminated string representing the key to remove.
+     */
     removeOption(key: string): 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: PixbufRotation): Pixbuf | null;
+    /**
+     * 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: Pixbuf, saturation: number, pixelate: boolean): void;
+    /**
+     * 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: Ref<number[]>, bufferSize: Ref<number>, type: string, optionKeys?: string[] | null, optionValues?: string[] | null): boolean;
+    /**
+     * 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: (...args: unknown[]) => unknown, type: string, userData?: number | null, optionKeys?: string[] | null, optionValues?: string[] | null): boolean;
+    /**
+     * 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: Gio.OutputStream, type: string, optionKeys?: string[] | null, optionValues?: string[] | null, cancellable?: Gio.Cancellable | null): boolean;
+    /**
+     * 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: string, type: string, optionKeys?: string[] | null, optionValues?: string[] | null): boolean;
+    /**
+     * 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: Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: InterpType): void;
+    /**
+     * 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: number, destHeight: number, interpType: InterpType): Pixbuf | null;
+    /**
+     * 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: string, value: string): boolean;
     connect(signal: "notify", handler: (self: Pixbuf, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;