@gtkx/ffi 0.10.5 → 0.11.1

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

@@ -4,6 +4,140 @@ 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 {@link 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 {@link 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 {@link 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
+ * {@link 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 {@link 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 {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -14,11 +148,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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);
     /**
@@ -28,13 +157,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -44,13 +166,12 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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 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;
     /**
@@ -60,10 +181,10 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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 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`.
      *
@@ -76,10 +197,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -89,10 +206,10 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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 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`.
      *
@@ -101,9 +218,6 @@ export declare class Pixbuf extends GObject.GObject {
      * than `width` x `height`, if the aspect ratio requires it. To load
      * and image at the requested size, regardless of aspect ratio, use
      * {@link 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;
     /**
@@ -140,9 +254,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -150,7 +261,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -167,10 +277,6 @@ export declare class Pixbuf extends GObject.GObject {
      * `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;
     /**
@@ -186,10 +292,8 @@ export declare class Pixbuf extends GObject.GObject {
      * `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): Pixbuf;
+    static newFromStream(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null): Pixbuf;
     /**
      * Creates a new pixbuf by loading an image from an input stream.
      *
@@ -212,17 +316,11 @@ export declare class Pixbuf extends GObject.GObject {
      * 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): Pixbuf;
+    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;
     /**
@@ -230,7 +328,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -239,20 +336,10 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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>, height?: Ref<number>): PixbufFormat;
+    /** Parses an image file far enough to determine its format and size. */
+    static getFileInfo(filename: string, width?: Ref<number> | null, height?: Ref<number> | null): PixbufFormat | null;
     /**
      * Asynchronously parses an image file far enough to determine its
      * format and size.
@@ -263,20 +350,13 @@ export declare class Pixbuf extends GObject.GObject {
      * 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, callback?: (source: unknown, result: unknown) => void): void;
+    static getFileInfoAsync(filename: string, cancellable?: Gio.Cancellable | null, callback?: (source_object: GObject.GObject | null, res: Gio.AsyncResult) => 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;
+    static getFileInfoFinish(asyncResult: Gio.AsyncResult, width: Ref<number>, height: Ref<number>): PixbufFormat | null;
     /**
      * Obtains the available information about the image formats supported
      * by GdkPixbuf.
@@ -296,7 +376,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -308,12 +387,8 @@ export declare class Pixbuf extends GObject.GObject {
      * 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, callback?: (source: unknown, result: unknown) => void): void;
+    static newFromStreamAsync(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null, callback?: (source_object: GObject.GObject | null, res: Gio.AsyncResult) => void | null): void;
     /**
      * Creates a new pixbuf by asynchronously loading an image from an input stream.
      *
@@ -322,19 +397,11 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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, callback?: (source: unknown, result: unknown) => void): void;
+    static newFromStreamAtScaleAsync(stream: Gio.InputStream, width: number, height: number, preserveAspectRatio: boolean, cancellable?: Gio.Cancellable | null, callback?: (source_object: GObject.GObject | null, res: Gio.AsyncResult) => 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;
     /**
@@ -351,10 +418,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -384,17 +447,6 @@ export declare class Pixbuf extends GObject.GObject {
      * to infinity.
      *
      * ![](https://docs.gtk.org/gdk-pixbuf/composite.png)
-     * @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;
     /**
@@ -410,35 +462,12 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -457,13 +486,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -473,7 +495,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -482,38 +503,24 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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.
-     */
+    /** Queries the number of bits per color sample in a pixbuf. */
     getBitsPerSample(): number;
-    /**
-     * Returns the length of the pixel data, in bytes.
-     */
+    /** Returns the length of the pixel data, in bytes. */
     getByteLength(): number;
-    /**
-     * Queries the color space of a pixbuf.
-     */
+    /** Queries the color space of a pixbuf. */
     getColorspace(): Colorspace;
-    /**
-     * Queries whether a pixbuf has an alpha channel (opacity information).
-     */
+    /** Queries whether a pixbuf has an alpha channel (opacity information). */
     getHasAlpha(): boolean;
-    /**
-     * Queries the height of a pixbuf.
-     */
+    /** Queries the height of a pixbuf. */
     getHeight(): number;
-    /**
-     * Queries the number of channels of a pixbuf.
-     */
+    /** 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
@@ -531,7 +538,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -539,7 +545,7 @@ export declare class Pixbuf extends GObject.GObject {
      * attached to the `pixbuf` when it was loaded, or that may have been
      * attached by another function using {@link GdkPixbuf.Pixbuf.set_option}.
      */
-    getOptions(): GLib.HashTable;
+    getOptions(): Map<string, string>;
     /**
      * Queries a pointer to the pixel data of a pixbuf.
      *
@@ -558,7 +564,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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[];
     /**
@@ -566,9 +571,7 @@ export declare class Pixbuf extends GObject.GObject {
      * the start of a row and the start of the next row.
      */
     getRowstride(): number;
-    /**
-     * Queries the width of a pixbuf.
-     */
+    /** Queries the width of a pixbuf. */
     getWidth(): number;
     /**
      * Creates a new pixbuf which represents a sub-region of `src_pixbuf`.
@@ -580,10 +583,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -601,17 +600,13 @@ export declare class Pixbuf extends GObject.GObject {
      * 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.
-     */
+    /** Removes the key/value pair option attached to a `GdkPixbuf`. */
     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;
     /**
@@ -629,9 +624,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
     /**
@@ -641,13 +633,8 @@ export declare class Pixbuf extends GObject.GObject {
      * "tiff", "png", "ico" or "bmp".
      *
      * See {@link 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[], optionValues?: string[]): boolean;
+    saveToBufferv(buffer: Ref<number[]>, bufferSize: Ref<number>, type: string, optionKeys?: string[] | null, optionValues?: string[] | null): boolean;
     /**
      * Saves `pixbuf` to an output stream.
      *
@@ -655,13 +642,20 @@ export declare class Pixbuf extends GObject.GObject {
      * "bmp".
      *
      * See {@link 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[], optionValues?: string[], cancellable?: Gio.Cancellable): boolean;
+    saveToStreamv(stream: Gio.OutputStream, type: string, optionKeys?: string[] | null, optionValues?: string[] | null, cancellable?: Gio.Cancellable | null): boolean;
+    /**
+     * Saves `pixbuf` to an output stream asynchronously.
+     *
+     * For more details see gdk_pixbuf_save_to_streamv(), 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_save_to_stream_finish() to get the result of
+     * the operation.
+     */
+    saveToStreamvAsync(stream: Gio.OutputStream, type: string, optionKeys?: string[] | null, optionValues?: string[] | null, cancellable?: Gio.Cancellable | null, callback?: (source_object: GObject.GObject | null, res: Gio.AsyncResult) => void | null): void;
     /**
      * Vector version of `gdk_pixbuf_save()`.
      *
@@ -670,12 +664,8 @@ export declare class Pixbuf extends GObject.GObject {
      * If `error` is set, `FALSE` will be returned.
      *
      * See {@link 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[], optionValues?: string[]): boolean;
+    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`,
@@ -690,16 +680,6 @@ export declare class Pixbuf extends GObject.GObject {
      * 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;
     /**
@@ -721,9 +701,6 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * For more complicated scaling/alpha blending see {@link GdkPixbuf.Pixbuf.scale}
      * and {@link 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;
     /**
@@ -731,18 +708,11 @@ export declare class Pixbuf extends GObject.GObject {
      *
      * 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;
-    /**
-     * Checks if two icons are equal.
-     * @param icon2 - pointer to the second #GIcon.
-     */
-    equal(icon2?: Gio.Icon): boolean;
-    /**
-     * Gets a hash for an icon.
-     */
+    /** Checks if two icons are equal. */
+    equal(icon2?: Gio.Icon | null): boolean;
+    /** Gets a hash for an icon. */
     hash(): number;
     /**
      * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
@@ -762,29 +732,26 @@ export declare class Pixbuf extends GObject.GObject {
      * in the following two cases
      *
      * - If `icon` is a #GFileIcon, the returned string is a native path
-     * (such as `/path/to/my icon.png`) without escaping
-     * if the #GFile for `icon` is a native file.  If the file is not
-     * native, the returned string is the result of g_file_get_uri()
-     * (such as `sftp://path/to/my%20icon.png`).
+     *   (such as `/path/to/my icon.png`) without escaping
+     *   if the #GFile for `icon` is a native file.  If the file is not
+     *   native, the returned string is the result of g_file_get_uri()
+     *   (such as `sftp://path/to/my%20icon.png`).
      *
      * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
-     * the encoding is simply the name (such as `network-server`).
+     *   the encoding is simply the name (such as `network-server`).
      */
     toString(): string | null;
     /**
      * Loads a loadable icon. For the asynchronous version of this function,
      * see g_loadable_icon_load_async().
-     * @param size - an integer.
-     * @param type - a location to store the type of the loaded
-     * @param cancellable - optional #GCancellable object, %NULL to
      */
-    load(size: number, type?: Ref<string>, cancellable?: Gio.Cancellable): Gio.InputStream;
+    load(size: number, type?: Ref<string> | null, cancellable?: Gio.Cancellable | null): Gio.InputStream;
     /**
-     * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
-     * @param res - a #GAsyncResult.
-     * @param type - a location to store the type of the loaded
+     * Loads an icon asynchronously. To finish this function, see
+     * g_loadable_icon_load_finish(). For the synchronous, blocking
+     * version of this function, see g_loadable_icon_load().
      */
-    loadFinish(res: Gio.AsyncResult, type?: Ref<string>): Gio.InputStream;
-    connect(signal: "notify", handler: (self: Pixbuf, pspec: GObject.ParamSpec) => void, after?: boolean): number;
-    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
+    loadAsync(size: number, cancellable?: Gio.Cancellable | null, callback?: (source_object: GObject.GObject | null, res: Gio.AsyncResult) => void | null): void;
+    /** Finishes an asynchronous icon load started in g_loadable_icon_load_async(). */
+    loadFinish(res: Gio.AsyncResult, type?: Ref<string> | null): Gio.InputStream;
 }