@girs/gdkpixbuf-2.0 2.0.0-3.0.0-beta.12

package/gdkpixbuf-2.0.d.cts

@@ -0,0 +1,2707 @@
+
+/*
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gjs
+ */
+/**
+ * GdkPixbuf-2.0
+ */
+
+import type Gio from '@girs/gio-2.0';
+import type GObject from '@girs/gobject-2.0';
+import type GLib from '@girs/glib-2.0';
+import type GModule from '@girs/gmodule-2.0';
+
+/**
+ * This enumeration defines the color spaces that are supported by
+ * the gdk-pixbuf library.
+ * 
+ * Currently only RGB is supported.
+ */
+export enum Colorspace {
+    /**
+     * Indicates a red/green/blue additive color space.
+     */
+    RGB,
+}
+/**
+ * Interpolation modes for scaling functions.
+ * 
+ * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has
+ * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best
+ * choice if you aren't sure what to choose, it has a good speed/quality
+ * balance.
+ * 
+ * **Note**: Cubic filtering is missing from the list; hyperbolic
+ * interpolation is just as fast and results in higher quality.
+ */
+export enum InterpType {
+    /**
+     * Nearest neighbor sampling; this is the fastest
+     *  and lowest quality mode. Quality is normally unacceptable when scaling
+     *  down, but may be OK when scaling up.
+     */
+    NEAREST,
+    /**
+     * This is an accurate simulation of the PostScript
+     *  image operator without any interpolation enabled.  Each pixel is
+     *  rendered as a tiny parallelogram of solid color, the edges of which
+     *  are implemented with antialiasing.  It resembles nearest neighbor for
+     *  enlargement, and bilinear for reduction.
+     */
+    TILES,
+    /**
+     * Best quality/speed balance; use this mode by
+     *  default. Bilinear interpolation.  For enlargement, it is
+     *  equivalent to point-sampling the ideal bilinear-interpolated image.
+     *  For reduction, it is equivalent to laying down small tiles and
+     *  integrating over the coverage area.
+     */
+    BILINEAR,
+    /**
+     * This is the slowest and highest quality
+     *  reconstruction function. It is derived from the hyperbolic filters in
+     *  Wolberg's "Digital Image Warping", and is formally defined as the
+     *  hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
+     *  image (the filter is designed to be idempotent for 1:1 pixel mapping).
+     *  **Deprecated**: this interpolation filter is deprecated, as in reality
+     *  it has a lower quality than the `GDK_INTERP_BILINEAR` filter
+     *  (Since: 2.38)
+     */
+    HYPER,
+}
+/**
+ * Control the alpha channel for drawables.
+ * 
+ * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha()
+ * in gdk-pixbuf-xlib to control how the alpha channel of an image should
+ * be handled.
+ * 
+ * This function can create a bilevel clipping mask (black and white) and use
+ * it while painting the image.
+ * 
+ * In the future, when the X Window System gets an alpha channel extension,
+ * it will be possible to do full alpha compositing onto arbitrary drawables.
+ * For now both cases fall back to a bilevel clipping mask.
+ */
+export enum PixbufAlphaMode {
+    /**
+     * A bilevel clipping mask (black and white)
+     *  will be created and used to draw the image.  Pixels below 0.5 opacity
+     *  will be considered fully transparent, and all others will be
+     *  considered fully opaque.
+     */
+    BILEVEL,
+    /**
+     * For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
+     *  In the future it will do full alpha compositing.
+     */
+    FULL,
+}
+/**
+ * An error code in the `GDK_PIXBUF_ERROR` domain.
+ * 
+ * Many gdk-pixbuf operations can cause errors in this domain, or in
+ * the `G_FILE_ERROR` domain.
+ */
+export enum PixbufError {
+    /**
+     * An image file was broken somehow.
+     */
+    CORRUPT_IMAGE,
+    /**
+     * Not enough memory.
+     */
+    INSUFFICIENT_MEMORY,
+    /**
+     * A bad option was passed to a pixbuf save module.
+     */
+    BAD_OPTION,
+    /**
+     * Unknown image type.
+     */
+    UNKNOWN_TYPE,
+    /**
+     * Don't know how to perform the
+     *  given operation on the type of image at hand.
+     */
+    UNSUPPORTED_OPERATION,
+    /**
+     * Generic failure code, something went wrong.
+     */
+    FAILED,
+    /**
+     * Only part of the animation was loaded.
+     */
+    INCOMPLETE_ANIMATION,
+}
+/**
+ * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
+ * 
+ * To make them easier to use, their numerical values are the actual degrees.
+ */
+export enum PixbufRotation {
+    /**
+     * No rotation.
+     */
+    NONE,
+    /**
+     * Rotate by 90 degrees.
+     */
+    COUNTERCLOCKWISE,
+    /**
+     * Rotate by 180 degrees.
+     */
+    UPSIDEDOWN,
+    /**
+     * Rotate by 270 degrees.
+     */
+    CLOCKWISE,
+}
+/**
+ * Flags which allow a module to specify further details about the supported
+ * operations.
+ * @bitfield 
+ */
+export enum PixbufFormatFlags {
+    /**
+     * the module can write out images in the format.
+     */
+    WRITABLE,
+    /**
+     * the image format is scalable
+     */
+    SCALABLE,
+    /**
+     * the module is threadsafe. gdk-pixbuf
+     *     ignores modules that are not marked as threadsafe. (Since 2.28).
+     */
+    THREADSAFE,
+}
+/**
+ * Major version of gdk-pixbuf library, that is the "0" in
+ * "0.8.2" for example.
+ */
+export const PIXBUF_MAJOR: number
+/**
+ * Micro version of gdk-pixbuf library, that is the "2" in
+ * "0.8.2" for example.
+ */
+export const PIXBUF_MICRO: number
+/**
+ * Minor version of gdk-pixbuf library, that is the "8" in
+ * "0.8.2" for example.
+ */
+export const PIXBUF_MINOR: number
+/**
+ * Contains the full version of GdkPixbuf as a string.
+ * 
+ * This is the version being compiled against; contrast with
+ * `gdk_pixbuf_version`.
+ */
+export const PIXBUF_VERSION: string | null
+export function pixbuf_error_quark(): GLib.Quark
+/**
+ * A function of this type is responsible for freeing the pixel array
+ * of a pixbuf.
+ * 
+ * The gdk_pixbuf_new_from_data() function lets you pass in a pre-allocated
+ * pixel array so that a pixbuf can be created from it; in this case you
+ * will need to pass in a function of type `GdkPixbufDestroyNotify` so that
+ * the pixel data can be freed when the pixbuf is finalized.
+ * @callback 
+ * @param pixels The pixel array of the pixbuf   that is being finalized.
+ */
+export interface PixbufDestroyNotify {
+    (pixels: Uint8Array): void
+}
+/**
+ * Defines the type of the function used to fill a
+ * #GdkPixbufFormat structure with information about a module.
+ * @callback 
+ * @param info a #GdkPixbufFormat.
+ */
+export interface PixbufModuleFillInfoFunc {
+    (info: PixbufFormat): void
+}
+/**
+ * Defines the type of the function used to set the vtable of a
+ * #GdkPixbufModule when it is loaded.
+ * @callback 
+ * @param module a #GdkPixbufModule.
+ */
+export interface PixbufModuleFillVtableFunc {
+    (module: PixbufModule): void
+}
+/**
+ * Defines the type of the function that gets called once the initial
+ * setup of `pixbuf` is done.
+ * 
+ * #GdkPixbufLoader uses a function of this type to emit the
+ * "<link linkend="GdkPixbufLoader-area-prepared">area_prepared</link>"
+ * signal.
+ * @callback 
+ * @param pixbuf the #GdkPixbuf that is currently being loaded.
+ * @param anim if an animation is being loaded, the #GdkPixbufAnimation, else %NULL.
+ */
+export interface PixbufModulePreparedFunc {
+    (pixbuf: Pixbuf, anim: PixbufAnimation): void
+}
+/**
+ * Defines the type of the function that gets called once the size
+ * of the loaded image is known.
+ * 
+ * The function is expected to set `width` and `height` to the desired
+ * size to which the image should be scaled. If a module has no efficient
+ * way to achieve the desired scaling during the loading of the image, it may
+ * either ignore the size request, or only approximate it - gdk-pixbuf will
+ * then perform the required scaling on the completely loaded image.
+ * 
+ * If the function sets `width` or `height` to zero, the module should interpret
+ * this as a hint that it will be closed soon and shouldn't allocate further
+ * resources. This convention is used to implement gdk_pixbuf_get_file_info()
+ * efficiently.
+ * @callback 
+ * @param width pointer to a location containing the current image width
+ * @param height pointer to a location containing the current image height
+ */
+export interface PixbufModuleSizeFunc {
+    (width: number, height: number): void
+}
+/**
+ * Defines the type of the function that gets called every time a region
+ * of `pixbuf` is updated.
+ * 
+ * #GdkPixbufLoader uses a function of this type to emit the
+ * "<link linkend="GdkPixbufLoader-area-updated">area_updated</link>"
+ * signal.
+ * @callback 
+ * @param pixbuf the #GdkPixbuf that is currently being loaded.
+ * @param x the X origin of the updated area.
+ * @param y the Y origin of the updated area.
+ * @param width the width of the updated area.
+ * @param height the height of the updated area.
+ */
+export interface PixbufModuleUpdatedFunc {
+    (pixbuf: Pixbuf, x: number, y: number, width: number, height: number): void
+}
+/**
+ * Save functions used by [method`GdkPixbuf`.Pixbuf.save_to_callback].
+ * 
+ * This function is called once for each block of bytes that is "written"
+ * by `gdk_pixbuf_save_to_callback()`.
+ * 
+ * If successful it should return `TRUE`; if an error occurs it should set
+ * `error` and return `FALSE`, in which case `gdk_pixbuf_save_to_callback()`
+ * will fail with the same error.
+ * @callback 
+ * @param buf bytes to be written.
+ * @returns `TRUE` if successful, `FALSE` otherwise
+ */
+export interface PixbufSaveFunc {
+    (buf: Uint8Array): boolean
+}
+export module Pixbuf {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends Gio.Icon.ConstructorProperties, Gio.LoadableIcon.ConstructorProperties, GObject.Object.ConstructorProperties {
+
+        // Own constructor properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf
+
+        /**
+         * The number of bits per sample.
+         * 
+         * Currently only 8 bit per sample are supported.
+         */
+        bits_per_sample?: number | null
+        /**
+         * The color space of the pixbuf.
+         * 
+         * Currently, only `GDK_COLORSPACE_RGB` is supported.
+         */
+        colorspace?: Colorspace | null
+        /**
+         * Whether the pixbuf has an alpha channel.
+         */
+        has_alpha?: boolean | null
+        /**
+         * The number of rows of the pixbuf.
+         */
+        height?: number | null
+        /**
+         * The number of samples per pixel.
+         * 
+         * Currently, only 3 or 4 samples per pixel are supported.
+         */
+        n_channels?: number | null
+        pixel_bytes?: GLib.Bytes | null
+        /**
+         * A pointer to the pixel data of the pixbuf.
+         */
+        pixels?: any | null
+        /**
+         * The number of bytes between the start of a row and
+         * the start of the next row.
+         * 
+         * This number must (obviously) be at least as large as the
+         * width of the pixbuf.
+         */
+        rowstride?: number | null
+        /**
+         * The number of columns of the pixbuf.
+         */
+        width?: number | null
+    }
+
+}
+
+export interface Pixbuf extends Gio.Icon, Gio.LoadableIcon {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf
+
+    /**
+     * The number of bits per sample.
+     * 
+     * Currently only 8 bit per sample are supported.
+     */
+    readonly bits_per_sample: number
+    /**
+     * The color space of the pixbuf.
+     * 
+     * Currently, only `GDK_COLORSPACE_RGB` is supported.
+     */
+    readonly colorspace: Colorspace
+    /**
+     * Whether the pixbuf has an alpha channel.
+     */
+    readonly has_alpha: boolean
+    /**
+     * The number of rows of the pixbuf.
+     */
+    readonly height: number
+    /**
+     * The number of samples per pixel.
+     * 
+     * Currently, only 3 or 4 samples per pixel are supported.
+     */
+    readonly n_channels: number
+    readonly pixel_bytes: GLib.Bytes
+    /**
+     * A pointer to the pixel data of the pixbuf.
+     */
+    readonly pixels: any
+    /**
+     * The number of bytes between the start of a row and
+     * the start of the next row.
+     * 
+     * This number must (obviously) be at least as large as the
+     * width of the pixbuf.
+     */
+    readonly rowstride: number
+    /**
+     * The number of columns of the pixbuf.
+     */
+    readonly width: number
+
+    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.Pixbuf
+
+    /**
+     * 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 substitute_color 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.
+     * @returns A newly-created pixbuf
+     */
+    add_alpha(substitute_color: boolean, r: number, g: number, b: number): 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.
+     * @returns A newly-created pixbuf
+     */
+    apply_embedded_orientation(): 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.
+     * 
+     * ![](composite.png)
+     * @param dest the #GdkPixbuf into which to render the results
+     * @param dest_x the left coordinate for region to render
+     * @param dest_y the top coordinate for region to render
+     * @param dest_width the width of the region to render
+     * @param dest_height the height of the region to render
+     * @param offset_x the offset in the X direction (currently rounded to an integer)
+     * @param offset_y the offset in the Y direction (currently rounded to an integer)
+     * @param scale_x the scale factor in the X direction
+     * @param scale_y the scale factor in the Y direction
+     * @param interp_type the interpolation type for the transformation.
+     * @param overall_alpha overall alpha for source image (0..255)
+     */
+    composite(dest: Pixbuf, dest_x: number, dest_y: number, dest_width: number, dest_height: number, offset_x: number, offset_y: number, scale_x: number, scale_y: number, interp_type: InterpType, overall_alpha: 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 dest_x the left coordinate for region to render
+     * @param dest_y the top coordinate for region to render
+     * @param dest_width the width of the region to render
+     * @param dest_height the height of the region to render
+     * @param offset_x the offset in the X direction (currently rounded to an integer)
+     * @param offset_y the offset in the Y direction (currently rounded to an integer)
+     * @param scale_x the scale factor in the X direction
+     * @param scale_y the scale factor in the Y direction
+     * @param interp_type the interpolation type for the transformation.
+     * @param overall_alpha overall alpha for source image (0..255)
+     * @param check_x the X offset for the checkboard (origin of checkboard is at -`check_x,` -`check_y)`
+     * @param check_y the Y offset for the checkboard
+     * @param check_size 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
+     */
+    composite_color(dest: Pixbuf, dest_x: number, dest_y: number, dest_width: number, dest_height: number, offset_x: number, offset_y: number, scale_x: number, scale_y: number, interp_type: InterpType, overall_alpha: number, check_x: number, check_y: number, check_size: 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 dest_width the width of destination image
+     * @param dest_height the height of destination image
+     * @param interp_type the interpolation type for the transformation.
+     * @param overall_alpha overall alpha for source image (0..255)
+     * @param check_size 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
+     * @returns the new pixbuf
+     */
+    composite_color_simple(dest_width: number, dest_height: number, interp_type: InterpType, overall_alpha: number, check_size: 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.
+     * @returns A newly-created pixbuf
+     */
+    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 src_x Source X coordinate within `src_pixbuf`.
+     * @param src_y Source Y coordinate within `src_pixbuf`.
+     * @param width Width of the area to copy.
+     * @param height Height of the area to copy.
+     * @param dest_pixbuf Destination pixbuf.
+     * @param dest_x X coordinate within `dest_pixbuf`.
+     * @param dest_y Y coordinate within `dest_pixbuf`.
+     */
+    copy_area(src_x: number, src_y: number, width: number, height: number, dest_pixbuf: Pixbuf, dest_x: number, dest_y: 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 dest_pixbuf the destination pixbuf
+     * @returns `TRUE` on success.
+     */
+    copy_options(dest_pixbuf: 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,   `0x00000000` transparent black)
+     */
+    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
+     * @returns the new pixbuf
+     */
+    flip(horizontal: boolean): Pixbuf | null
+    /**
+     * Queries the number of bits per color sample in a pixbuf.
+     * @returns Number of bits per color sample.
+     */
+    get_bits_per_sample(): number
+    /**
+     * Returns the length of the pixel data, in bytes.
+     * @returns The length of the pixel data.
+     */
+    get_byte_length(): number
+    /**
+     * Queries the color space of a pixbuf.
+     * @returns Color space.
+     */
+    get_colorspace(): Colorspace
+    /**
+     * Queries whether a pixbuf has an alpha channel (opacity information).
+     * @returns `TRUE` if it has an alpha channel, `FALSE` otherwise.
+     */
+    get_has_alpha(): boolean
+    /**
+     * Queries the height of a pixbuf.
+     * @returns Height in pixels.
+     */
+    get_height(): number
+    /**
+     * Queries the number of channels of a pixbuf.
+     * @returns Number of channels.
+     */
+    get_n_channels(): 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.
+     * @returns the value associated with `key`
+     */
+    get_option(key: string | null): 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].
+     * @returns a #GHashTable   of key/values pairs
+     */
+    get_options(): 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](class.Pixbuf.html#image-data) for information
+     * about how the pixel data is stored in memory.
+     * @returns A pointer to the pixbuf's pixel data.
+     */
+    get_pixels(): Uint8Array
+    /**
+     * 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.
+     * @returns Distance between row starts.
+     */
+    get_rowstride(): number
+    /**
+     * Queries the width of a pixbuf.
+     * @returns Width in pixels.
+     */
+    get_width(): 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 src_x X coord in `src_pixbuf`
+     * @param src_y Y coord in `src_pixbuf`
+     * @param width width of region in `src_pixbuf`
+     * @param height height of region in `src_pixbuf`
+     * @returns a new pixbuf
+     */
+    new_subpixbuf(src_x: number, src_y: 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.
+     * @returns A new reference to a read-only copy of   the pixel data.  Note that for mutable pixbufs, this function will   incur a one-time copy of the pixel data for conversion into the   returned #GBytes.
+     */
+    read_pixel_bytes(): 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.
+     * @returns a read-only pointer to the raw pixel data
+     */
+    read_pixels(): number
+    /**
+     * Removes the key/value pair option attached to a `GdkPixbuf`.
+     * @param key a nul-terminated string representing the key to remove.
+     * @returns `TRUE` if an option was removed, `FALSE` if not.
+     */
+    remove_option(key: string | null): 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
+     * @returns the new pixbuf
+     */
+    rotate_simple(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
+     */
+    saturate_and_pixelate(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 type name of file format.
+     * @param option_keys name of options to set
+     * @param option_values values for named options
+     * @returns whether an error was set
+     */
+    save_to_bufferv(type: string | null, option_keys: string[] | null, option_values: string[] | null): [ /* returnType */ boolean, /* buffer */ Uint8Array ]
+    /**
+     * 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 save_func a function that is called to save each block of data that   the save routine generates.
+     * @param type name of file format.
+     * @param option_keys name of options to set
+     * @param option_values values for named options
+     * @returns whether an error was set
+     */
+    save_to_callbackv(save_func: PixbufSaveFunc, type: string | null, option_keys: string[] | null, option_values: 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 option_keys name of options to set
+     * @param option_values values for named options
+     * @param cancellable optional `GCancellable` object, `NULL` to ignore
+     * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an   error was set.
+     */
+    save_to_streamv(stream: Gio.OutputStream, type: string | null, option_keys: string[] | null, option_values: 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.
+     * @param stream a `GOutputStream` to which to save the pixbuf
+     * @param type name of file format
+     * @param option_keys name of options to set
+     * @param option_values values for named options
+     * @param cancellable optional `GCancellable` object, `NULL` to ignore
+     * @param callback a `GAsyncReadyCallback` to call when the pixbuf is saved
+     */
+    save_to_streamv_async(stream: Gio.OutputStream, type: string | null, option_keys: string[] | null, option_values: string[] | null, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void
+    /**
+     * 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 option_keys name of options to set
+     * @param option_values values for named options
+     * @returns whether an error was set
+     */
+    savev(filename: string, type: string | null, option_keys: string[] | null, option_values: 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 dest_x the left coordinate for region to render
+     * @param dest_y the top coordinate for region to render
+     * @param dest_width the width of the region to render
+     * @param dest_height the height of the region to render
+     * @param offset_x the offset in the X direction (currently rounded to an integer)
+     * @param offset_y the offset in the Y direction (currently rounded to an integer)
+     * @param scale_x the scale factor in the X direction
+     * @param scale_y the scale factor in the Y direction
+     * @param interp_type the interpolation type for the transformation.
+     */
+    scale(dest: Pixbuf, dest_x: number, dest_y: number, dest_width: number, dest_height: number, offset_x: number, offset_y: number, scale_x: number, scale_y: number, interp_type: 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 dest_width the width of destination image
+     * @param dest_height the height of destination image
+     * @param interp_type the interpolation type for the transformation.
+     * @returns the new pixbuf
+     */
+    scale_simple(dest_width: number, dest_height: number, interp_type: 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.
+     * @returns `TRUE` on success
+     */
+    set_option(key: string | null, value: string | null): boolean
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.Pixbuf
+
+    connect(sigName: "notify::bits-per-sample", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::bits-per-sample", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::bits-per-sample", ...args: any[]): void
+    connect(sigName: "notify::colorspace", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::colorspace", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::colorspace", ...args: any[]): void
+    connect(sigName: "notify::has-alpha", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::has-alpha", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::has-alpha", ...args: any[]): void
+    connect(sigName: "notify::height", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::height", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::height", ...args: any[]): void
+    connect(sigName: "notify::n-channels", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::n-channels", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::n-channels", ...args: any[]): void
+    connect(sigName: "notify::pixel-bytes", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::pixel-bytes", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::pixel-bytes", ...args: any[]): void
+    connect(sigName: "notify::pixels", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::pixels", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::pixels", ...args: any[]): void
+    connect(sigName: "notify::rowstride", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::rowstride", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::rowstride", ...args: any[]): void
+    connect(sigName: "notify::width", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::width", callback: (($obj: Pixbuf, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::width", ...args: any[]): void
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * 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.
+ * 
+ * As a special case, you can use the [`ctor`GdkPixbuf`.Pixbuf.new_from_xpm_data`]
+ * function to create a pixbuf from inline XPM image data.
+ * 
+ * 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.
+ * @class 
+ */
+export class Pixbuf extends GObject.Object {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf
+
+    static name: string
+    static $gtype: GObject.GType<Pixbuf>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.Pixbuf
+
+    constructor(config?: Pixbuf.ConstructorProperties) 
+    /**
+     * 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.
+     * @constructor 
+     * @param colorspace Color space for image
+     * @param has_alpha Whether the image should have transparency information
+     * @param bits_per_sample 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
+     * @returns A newly-created pixel buffer
+     */
+    constructor(colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number) 
+    /**
+     * 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.
+     * @constructor 
+     * @param colorspace Color space for image
+     * @param has_alpha Whether the image should have transparency information
+     * @param bits_per_sample 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
+     * @returns A newly-created pixel buffer
+     */
+    static new(colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number): Pixbuf
+    /**
+     * 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.
+     * @constructor 
+     * @param data Image data in 8-bit/sample packed format inside a #GBytes
+     * @param colorspace Colorspace for the image data
+     * @param has_alpha Whether the data has an opacity channel
+     * @param bits_per_sample 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
+     * @returns A newly-created pixbuf
+     */
+    static new_from_bytes(data: GLib.Bytes, colorspace: Colorspace, has_alpha: boolean, bits_per_sample: 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]
+     * @constructor 
+     * @param data Image data in 8-bit/sample packed format
+     * @param colorspace Colorspace for the image data
+     * @param has_alpha Whether the data has an opacity channel
+     * @param bits_per_sample 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 destroy_fn Function used to free the data when the pixbuf's reference count drops to zero, or %NULL if the data should not be freed
+     * @returns A newly-created pixbuf
+     */
+    static new_from_data(data: Uint8Array, colorspace: Colorspace, has_alpha: boolean, bits_per_sample: number, width: number, height: number, rowstride: number, destroy_fn: PixbufDestroyNotify | 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`.
+     * @constructor 
+     * @param filename Name of file to load, in the GLib file   name encoding
+     * @returns A newly-created pixbuf
+     */
+    static new_from_file(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.
+     * @constructor 
+     * @param filename Name of file to load, in the GLib file     name encoding
+     * @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 preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio
+     * @returns A newly-created pixbuf
+     */
+    static new_from_file_at_scale(filename: string, width: number, height: number, preserve_aspect_ratio: 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].
+     * @constructor 
+     * @param filename Name of file to load, in the GLib file     name encoding
+     * @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
+     * @returns A newly-created pixbuf
+     */
+    static new_from_file_at_size(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.
+     * @constructor 
+     * @param data Byte data containing a   serialized `GdkPixdata` structure
+     * @param copy_pixels Whether to copy the pixel data, or use direct pointers   `data` for the resulting pixbuf
+     * @returns A newly-created pixbuf
+     */
+    static new_from_inline(data: Uint8Array, copy_pixels: 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.
+     * @constructor 
+     * @param resource_path the path of the resource file
+     * @returns A newly-created pixbuf
+     */
+    static new_from_resource(resource_path: string | null): 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.
+     * @constructor 
+     * @param resource_path 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 preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio
+     * @returns A newly-created pixbuf
+     */
+    static new_from_resource_at_scale(resource_path: string | null, width: number, height: number, preserve_aspect_ratio: 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.
+     * @constructor 
+     * @param stream a `GInputStream` to load the pixbuf from
+     * @param cancellable optional `GCancellable` object, `NULL` to ignore
+     * @returns A newly-created pixbuf
+     */
+    static new_from_stream(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.
+     * @constructor 
+     * @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 preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio
+     * @param cancellable optional `GCancellable` object, `NULL` to ignore
+     * @returns A newly-created pixbuf
+     */
+    static new_from_stream_at_scale(stream: Gio.InputStream, width: number, height: number, preserve_aspect_ratio: boolean, cancellable: Gio.Cancellable | null): Pixbuf
+    /**
+     * Finishes an asynchronous pixbuf creation operation started with
+     * gdk_pixbuf_new_from_stream_async().
+     * @constructor 
+     * @param async_result a `GAsyncResult`
+     * @returns the newly created pixbuf
+     */
+    static new_from_stream_finish(async_result: 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.
+     * @constructor 
+     * @param data Pointer to inline XPM data.
+     * @returns A newly-created pixbuf
+     */
+    static new_from_xpm_data(data: string[]): Pixbuf
+    _init(config?: Pixbuf.ConstructorProperties): void
+    /**
+     * 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
+     */
+    static new_from_stream_async(stream: Gio.InputStream, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<Pixbuf> | 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 preserve_aspect_ratio `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
+     */
+    static new_from_stream_at_scale_async(stream: Gio.InputStream, width: number, height: number, preserve_aspect_ratio: boolean, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<Pixbuf> | null): void
+    /**
+     * 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 has_alpha Whether the image should have transparency information
+     * @param bits_per_sample 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
+     * @returns the rowstride for the given values, or -1 in case of error.
+     */
+    static calculate_rowstride(colorspace: Colorspace, has_alpha: boolean, bits_per_sample: 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.
+     * @returns A `GdkPixbufFormat` describing   the image format of the file
+     */
+    static get_file_info(filename: string): [ /* returnType */ PixbufFormat | null, /* width */ number, /* height */ number ]
+    /**
+     * 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
+     */
+    static get_file_info_async(filename: string, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<Pixbuf> | null): void
+    /**
+     * Finishes an asynchronous pixbuf parsing operation started with
+     * gdk_pixbuf_get_file_info_async().
+     * @param async_result a `GAsyncResult`
+     * @returns A `GdkPixbufFormat` describing the   image format of the file
+     */
+    static get_file_info_finish(async_result: Gio.AsyncResult): [ /* returnType */ PixbufFormat | null, /* width */ number, /* height */ number ]
+    /**
+     * Obtains the available information about the image formats supported
+     * by GdkPixbuf.
+     * @returns A list of   support image formats.
+     */
+    static get_formats(): 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 init_modules(path: string | null): boolean
+    /**
+     * Finishes an asynchronous pixbuf save operation started with
+     * gdk_pixbuf_save_to_stream_async().
+     * @param async_result a `GAsyncResult`
+     * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set.
+     */
+    static save_to_stream_finish(async_result: Gio.AsyncResult): boolean
+}
+
+export module PixbufAnimation {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+    }
+
+}
+
+export interface PixbufAnimation {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation
+
+    parent_instance: GObject.Object
+
+    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation
+
+    /**
+     * Queries the height of the bounding box of a pixbuf animation.
+     * @returns Height of the bounding box of the animation.
+     */
+    get_height(): number
+    /**
+     * Get an iterator for displaying an animation.
+     * 
+     * The iterator provides the frames that should be displayed at a
+     * given time.
+     * 
+     * `start_time` would normally come from g_get_current_time(), and marks
+     * the beginning of animation playback. After creating an iterator, you
+     * should immediately display the pixbuf returned by
+     * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
+     * a timeout (with g_timeout_add()) or by some other mechanism ensure
+     * that you'll update the image after
+     * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
+     * the image is updated, you should reinstall the timeout with the new,
+     * possibly-changed delay time.
+     * 
+     * As a shortcut, if `start_time` is `NULL`, the result of
+     * g_get_current_time() will be used automatically.
+     * 
+     * To update the image (i.e. possibly change the result of
+     * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
+     * call gdk_pixbuf_animation_iter_advance().
+     * 
+     * If you're using #GdkPixbufLoader, in addition to updating the image
+     * after the delay time, you should also update it whenever you
+     * receive the area_updated signal and
+     * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
+     * `TRUE`. In this case, the frame currently being fed into the loader
+     * has received new data, so needs to be refreshed. The delay time for
+     * a frame may also be modified after an area_updated signal, for
+     * example if the delay time for a frame is encoded in the data after
+     * the frame itself. So your timeout should be reinstalled after any
+     * area_updated signal.
+     * 
+     * A delay time of -1 is possible, indicating "infinite".
+     * @param start_time time when the animation starts playing
+     * @returns an iterator to move over the animation
+     */
+    get_iter(start_time: GLib.TimeVal | null): PixbufAnimationIter
+    /**
+     * Retrieves a static image for the animation.
+     * 
+     * If an animation is really just a plain image (has only one frame),
+     * this function returns that image.
+     * 
+     * If the animation is an animation, this function returns a reasonable
+     * image to use as a static unanimated image, which might be the first
+     * frame, or something more sophisticated depending on the file format.
+     * 
+     * If an animation hasn't loaded any frames yet, this function will
+     * return `NULL`.
+     * @returns unanimated image representing the animation
+     */
+    get_static_image(): Pixbuf
+    /**
+     * Queries the width of the bounding box of a pixbuf animation.
+     * @returns Width of the bounding box of the animation.
+     */
+    get_width(): number
+    /**
+     * Checks whether the animation is a static image.
+     * 
+     * If you load a file with gdk_pixbuf_animation_new_from_file() and it
+     * turns out to be a plain, unanimated image, then this function will
+     * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
+     * the image.
+     * @returns `TRUE` if the "animation" was really just an image
+     */
+    is_static_image(): boolean
+
+    // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation
+
+    /**
+     * Get an iterator for displaying an animation.
+     * 
+     * The iterator provides the frames that should be displayed at a
+     * given time.
+     * 
+     * `start_time` would normally come from g_get_current_time(), and marks
+     * the beginning of animation playback. After creating an iterator, you
+     * should immediately display the pixbuf returned by
+     * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
+     * a timeout (with g_timeout_add()) or by some other mechanism ensure
+     * that you'll update the image after
+     * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
+     * the image is updated, you should reinstall the timeout with the new,
+     * possibly-changed delay time.
+     * 
+     * As a shortcut, if `start_time` is `NULL`, the result of
+     * g_get_current_time() will be used automatically.
+     * 
+     * To update the image (i.e. possibly change the result of
+     * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
+     * call gdk_pixbuf_animation_iter_advance().
+     * 
+     * If you're using #GdkPixbufLoader, in addition to updating the image
+     * after the delay time, you should also update it whenever you
+     * receive the area_updated signal and
+     * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
+     * `TRUE`. In this case, the frame currently being fed into the loader
+     * has received new data, so needs to be refreshed. The delay time for
+     * a frame may also be modified after an area_updated signal, for
+     * example if the delay time for a frame is encoded in the data after
+     * the frame itself. So your timeout should be reinstalled after any
+     * area_updated signal.
+     * 
+     * A delay time of -1 is possible, indicating "infinite".
+     * @virtual 
+     * @param start_time time when the animation starts playing
+     * @returns an iterator to move over the animation
+     */
+    vfunc_get_iter(start_time: GLib.TimeVal | null): PixbufAnimationIter
+    vfunc_get_size(width: number, height: number): void
+    /**
+     * Retrieves a static image for the animation.
+     * 
+     * If an animation is really just a plain image (has only one frame),
+     * this function returns that image.
+     * 
+     * If the animation is an animation, this function returns a reasonable
+     * image to use as a static unanimated image, which might be the first
+     * frame, or something more sophisticated depending on the file format.
+     * 
+     * If an animation hasn't loaded any frames yet, this function will
+     * return `NULL`.
+     * @virtual 
+     * @returns unanimated image representing the animation
+     */
+    vfunc_get_static_image(): Pixbuf
+    /**
+     * Checks whether the animation is a static image.
+     * 
+     * If you load a file with gdk_pixbuf_animation_new_from_file() and it
+     * turns out to be a plain, unanimated image, then this function will
+     * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
+     * the image.
+     * @virtual 
+     * @returns `TRUE` if the "animation" was really just an image
+     */
+    vfunc_is_static_image(): boolean
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation
+
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * An opaque object representing an animation.
+ * 
+ * The GdkPixBuf library provides a simple mechanism to load and
+ * represent animations. An animation is conceptually a series of
+ * frames to be displayed over time.
+ * 
+ * The animation may not be represented as a series of frames
+ * internally; for example, it may be stored as a sprite and
+ * instructions for moving the sprite around a background.
+ * 
+ * To display an animation you don't need to understand its
+ * representation, however; you just ask `GdkPixbuf` what should
+ * be displayed at a given point in time.
+ * @class 
+ */
+export class PixbufAnimation extends GObject.Object {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation
+
+    static name: string
+    static $gtype: GObject.GType<PixbufAnimation>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation
+
+    constructor(config?: PixbufAnimation.ConstructorProperties) 
+    /**
+     * Creates a new animation by loading it from a file.
+     * 
+     * The file format is detected automatically.
+     * 
+     * If the file's format does not support multi-frame images, then an animation
+     * with a single frame will be created.
+     * 
+     * Possible errors are in the `GDK_PIXBUF_ERROR` and `G_FILE_ERROR` domains.
+     * @constructor 
+     * @param filename Name of file to load, in the GLib file   name encoding
+     * @returns A newly-created animation
+     */
+    static new_from_file(filename: string): PixbufAnimation
+    /**
+     * Creates a new pixbuf animation by loading an image from an resource.
+     * 
+     * The file format is detected automatically. If `NULL` is returned, then
+     * `error` will be set.
+     * @constructor 
+     * @param resource_path the path of the resource file
+     * @returns A newly-created animation
+     */
+    static new_from_resource(resource_path: string | null): PixbufAnimation
+    /**
+     * Creates a new animation by loading it from an input stream.
+     * 
+     * The file format is detected automatically.
+     * 
+     * If `NULL` is returned, then `error` will be set.
+     * 
+     * The `cancellable` can be used to abort the operation from another thread.
+     * If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be
+     * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and
+     * `G_IO_ERROR` domains.
+     * 
+     * The stream is not closed.
+     * @constructor 
+     * @param stream a `GInputStream` to load the pixbuf from
+     * @param cancellable optional `GCancellable` object
+     * @returns A newly-created animation
+     */
+    static new_from_stream(stream: Gio.InputStream, cancellable: Gio.Cancellable | null): PixbufAnimation
+    /**
+     * Finishes an asynchronous pixbuf animation creation operation started with
+     * [func`GdkPixbuf`.PixbufAnimation.new_from_stream_async].
+     * @constructor 
+     * @param async_result a #GAsyncResult
+     * @returns the newly created animation
+     */
+    static new_from_stream_finish(async_result: Gio.AsyncResult): PixbufAnimation
+    _init(config?: PixbufAnimation.ConstructorProperties): void
+    /**
+     * Creates a new animation by asynchronously loading an image from an input stream.
+     * 
+     * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
+     * version of this function.
+     * 
+     * When the operation is finished, `callback` will be called in the main thread.
+     * You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
+     * result of the operation.
+     * @param stream a #GInputStream from which to load the animation
+     * @param cancellable optional #GCancellable object
+     * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
+     */
+    static new_from_stream_async(stream: Gio.InputStream, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<PixbufAnimation> | null): void
+}
+
+export module PixbufAnimationIter {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+    }
+
+}
+
+export interface PixbufAnimationIter {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter
+
+    parent_instance: GObject.Object
+
+    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter
+
+    /**
+     * Possibly advances an animation to a new frame.
+     * 
+     * Chooses the frame based on the start time passed to
+     * gdk_pixbuf_animation_get_iter().
+     * 
+     * `current_time` would normally come from g_get_current_time(), and
+     * must be greater than or equal to the time passed to
+     * gdk_pixbuf_animation_get_iter(), and must increase or remain
+     * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
+     * called. That is, you can't go backward in time; animations only
+     * play forward.
+     * 
+     * As a shortcut, pass `NULL` for the current time and g_get_current_time()
+     * will be invoked on your behalf. So you only need to explicitly pass
+     * `current_time` if you're doing something odd like playing the animation
+     * at double speed.
+     * 
+     * If this function returns `FALSE`, there's no need to update the animation
+     * display, assuming the display had been rendered prior to advancing;
+     * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
+     * and update the display with the new pixbuf.
+     * @param current_time current time
+     * @returns `TRUE` if the image may need updating
+     */
+    advance(current_time: GLib.TimeVal | null): boolean
+    /**
+     * Gets the number of milliseconds the current pixbuf should be displayed,
+     * or -1 if the current pixbuf should be displayed forever.
+     * 
+     * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
+     * so you can use a timeout to schedule the next update.
+     * 
+     * Note that some formats, like GIF, might clamp the timeout values in the
+     * image file to avoid updates that are just too quick. The minimum timeout
+     * for GIF images is currently 20 milliseconds.
+     * @returns delay time in milliseconds (thousandths of a second)
+     */
+    get_delay_time(): number
+    /**
+     * Gets the current pixbuf which should be displayed.
+     * 
+     * The pixbuf might not be the same size as the animation itself
+     * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
+     * 
+     * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
+     * milliseconds.
+     * 
+     * The caller of this function does not own a reference to the returned
+     * pixbuf; the returned pixbuf will become invalid when the iterator
+     * advances to the next frame, which may happen anytime you call
+     * gdk_pixbuf_animation_iter_advance().
+     * 
+     * Copy the pixbuf to keep it (don't just add a reference), as it may get
+     * recycled as you advance the iterator.
+     * @returns the pixbuf to be displayed
+     */
+    get_pixbuf(): Pixbuf
+    /**
+     * Used to determine how to respond to the area_updated signal on
+     * #GdkPixbufLoader when loading an animation.
+     * 
+     * The `::area_updated` signal is emitted for an area of the frame currently
+     * streaming in to the loader. So if you're on the currently loading frame,
+     * you will need to redraw the screen for the updated area.
+     * @returns `TRUE` if the frame we're on is partially loaded, or the last frame
+     */
+    on_currently_loading_frame(): boolean
+
+    // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter
+
+    /**
+     * Possibly advances an animation to a new frame.
+     * 
+     * Chooses the frame based on the start time passed to
+     * gdk_pixbuf_animation_get_iter().
+     * 
+     * `current_time` would normally come from g_get_current_time(), and
+     * must be greater than or equal to the time passed to
+     * gdk_pixbuf_animation_get_iter(), and must increase or remain
+     * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
+     * called. That is, you can't go backward in time; animations only
+     * play forward.
+     * 
+     * As a shortcut, pass `NULL` for the current time and g_get_current_time()
+     * will be invoked on your behalf. So you only need to explicitly pass
+     * `current_time` if you're doing something odd like playing the animation
+     * at double speed.
+     * 
+     * If this function returns `FALSE`, there's no need to update the animation
+     * display, assuming the display had been rendered prior to advancing;
+     * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
+     * and update the display with the new pixbuf.
+     * @virtual 
+     * @param current_time current time
+     * @returns `TRUE` if the image may need updating
+     */
+    vfunc_advance(current_time: GLib.TimeVal | null): boolean
+    /**
+     * Gets the number of milliseconds the current pixbuf should be displayed,
+     * or -1 if the current pixbuf should be displayed forever.
+     * 
+     * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
+     * so you can use a timeout to schedule the next update.
+     * 
+     * Note that some formats, like GIF, might clamp the timeout values in the
+     * image file to avoid updates that are just too quick. The minimum timeout
+     * for GIF images is currently 20 milliseconds.
+     * @virtual 
+     * @returns delay time in milliseconds (thousandths of a second)
+     */
+    vfunc_get_delay_time(): number
+    /**
+     * Gets the current pixbuf which should be displayed.
+     * 
+     * The pixbuf might not be the same size as the animation itself
+     * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
+     * 
+     * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
+     * milliseconds.
+     * 
+     * The caller of this function does not own a reference to the returned
+     * pixbuf; the returned pixbuf will become invalid when the iterator
+     * advances to the next frame, which may happen anytime you call
+     * gdk_pixbuf_animation_iter_advance().
+     * 
+     * Copy the pixbuf to keep it (don't just add a reference), as it may get
+     * recycled as you advance the iterator.
+     * @virtual 
+     * @returns the pixbuf to be displayed
+     */
+    vfunc_get_pixbuf(): Pixbuf
+    /**
+     * Used to determine how to respond to the area_updated signal on
+     * #GdkPixbufLoader when loading an animation.
+     * 
+     * The `::area_updated` signal is emitted for an area of the frame currently
+     * streaming in to the loader. So if you're on the currently loading frame,
+     * you will need to redraw the screen for the updated area.
+     * @virtual 
+     * @returns `TRUE` if the frame we're on is partially loaded, or the last frame
+     */
+    vfunc_on_currently_loading_frame(): boolean
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter
+
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * An opaque object representing an iterator which points to a
+ * certain position in an animation.
+ * @class 
+ */
+export class PixbufAnimationIter extends GObject.Object {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter
+
+    static name: string
+    static $gtype: GObject.GType<PixbufAnimationIter>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter
+
+    constructor(config?: PixbufAnimationIter.ConstructorProperties) 
+    _init(config?: PixbufAnimationIter.ConstructorProperties): void
+}
+
+export module PixbufLoader {
+
+    // Signal callback interfaces
+
+    /**
+     * Signal callback interface for `area-prepared`
+     */
+    export interface AreaPreparedSignalCallback {
+        ($obj: PixbufLoader): void
+    }
+
+    /**
+     * Signal callback interface for `area-updated`
+     */
+    export interface AreaUpdatedSignalCallback {
+        ($obj: PixbufLoader, x: number, y: number, width: number, height: number): void
+    }
+
+    /**
+     * Signal callback interface for `closed`
+     */
+    export interface ClosedSignalCallback {
+        ($obj: PixbufLoader): void
+    }
+
+    /**
+     * Signal callback interface for `size-prepared`
+     */
+    export interface SizePreparedSignalCallback {
+        ($obj: PixbufLoader, width: number, height: number): void
+    }
+
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+    }
+
+}
+
+export interface PixbufLoader {
+
+    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader
+
+    /**
+     * Informs a pixbuf loader that no further writes with
+     * gdk_pixbuf_loader_write() will occur, so that it can free its
+     * internal loading structures.
+     * 
+     * This function also tries to parse any data that hasn't yet been parsed;
+     * if the remaining data is partial or corrupt, an error will be returned.
+     * 
+     * If `FALSE` is returned, `error` will be set to an error from the
+     * `GDK_PIXBUF_ERROR` or `G_FILE_ERROR` domains.
+     * 
+     * If you're just cancelling a load rather than expecting it to be finished,
+     * passing `NULL` for `error` to ignore it is reasonable.
+     * 
+     * Remember that this function does not release a reference on the loader, so
+     * you will need to explicitly release any reference you hold.
+     * @returns `TRUE` if all image data written so far was successfully   passed out via the update_area signal
+     */
+    close(): boolean
+    /**
+     * Queries the #GdkPixbufAnimation that a pixbuf loader is currently creating.
+     * 
+     * In general it only makes sense to call this function after the
+     * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been emitted by
+     * the loader.
+     * 
+     * If the loader doesn't have enough bytes yet, and hasn't emitted the `area-prepared`
+     * signal, this function will return `NULL`.
+     * @returns The animation that the loader is   currently loading
+     */
+    get_animation(): PixbufAnimation | null
+    /**
+     * Obtains the available information about the format of the
+     * currently loading image file.
+     * @returns A #GdkPixbufFormat
+     */
+    get_format(): PixbufFormat | null
+    /**
+     * Queries the #GdkPixbuf that a pixbuf loader is currently creating.
+     * 
+     * In general it only makes sense to call this function after the
+     * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been
+     * emitted by the loader; this means that enough data has been read
+     * to know the size of the image that will be allocated.
+     * 
+     * If the loader has not received enough data via gdk_pixbuf_loader_write(),
+     * then this function returns `NULL`.
+     * 
+     * The returned pixbuf will be the same in all future calls to the loader,
+     * so if you want to keep using it, you should acquire a reference to it.
+     * 
+     * Additionally, if the loader is an animation, it will return the "static
+     * image" of the animation (see gdk_pixbuf_animation_get_static_image()).
+     * @returns The pixbuf that the loader is   creating
+     */
+    get_pixbuf(): Pixbuf | null
+    /**
+     * Causes the image to be scaled while it is loaded.
+     * 
+     * The desired image size can be determined relative to the original
+     * size of the image by calling gdk_pixbuf_loader_set_size() from a
+     * signal handler for the ::size-prepared signal.
+     * 
+     * Attempts to set the desired image size  are ignored after the
+     * emission of the ::size-prepared signal.
+     * @param width The desired width of the image being loaded.
+     * @param height The desired height of the image being loaded.
+     */
+    set_size(width: number, height: number): void
+    /**
+     * Parses the next `count` bytes in the given image buffer.
+     * @param buf Pointer to image data.
+     * @returns `TRUE` if the write was successful, or   `FALSE` if the loader cannot parse the buffer
+     */
+    write(buf: Uint8Array): boolean
+    /**
+     * Parses the next contents of the given image buffer.
+     * @param buffer The image data as a `GBytes` buffer.
+     * @returns `TRUE` if the write was successful, or `FALSE` if   the loader cannot parse the buffer
+     */
+    write_bytes(buffer: GLib.Bytes): boolean
+
+    // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader
+
+    vfunc_area_prepared(): void
+    vfunc_area_updated(x: number, y: number, width: number, height: number): void
+    vfunc_closed(): void
+    vfunc_size_prepared(width: number, height: number): void
+
+    // Own signals of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader
+
+    connect(sigName: "area-prepared", callback: PixbufLoader.AreaPreparedSignalCallback): number
+    connect_after(sigName: "area-prepared", callback: PixbufLoader.AreaPreparedSignalCallback): number
+    emit(sigName: "area-prepared", ...args: any[]): void
+    connect(sigName: "area-updated", callback: PixbufLoader.AreaUpdatedSignalCallback): number
+    connect_after(sigName: "area-updated", callback: PixbufLoader.AreaUpdatedSignalCallback): number
+    emit(sigName: "area-updated", x: number, y: number, width: number, height: number, ...args: any[]): void
+    connect(sigName: "closed", callback: PixbufLoader.ClosedSignalCallback): number
+    connect_after(sigName: "closed", callback: PixbufLoader.ClosedSignalCallback): number
+    emit(sigName: "closed", ...args: any[]): void
+    connect(sigName: "size-prepared", callback: PixbufLoader.SizePreparedSignalCallback): number
+    connect_after(sigName: "size-prepared", callback: PixbufLoader.SizePreparedSignalCallback): number
+    emit(sigName: "size-prepared", width: number, height: number, ...args: any[]): void
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader
+
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * Incremental image loader.
+ * 
+ * `GdkPixbufLoader` provides a way for applications to drive the
+ * process of loading an image, by letting them send the image data
+ * directly to the loader instead of having the loader read the data
+ * from a file. Applications can use this functionality instead of
+ * `gdk_pixbuf_new_from_file()` or `gdk_pixbuf_animation_new_from_file()`
+ * when they need to parse image data in small chunks. For example,
+ * it should be used when reading an image from a (potentially) slow
+ * network connection, or when loading an extremely large file.
+ * 
+ * To use `GdkPixbufLoader` to load an image, create a new instance,
+ * and call [method`GdkPixbuf`.PixbufLoader.write] to send the data
+ * to it. When done, [method`GdkPixbuf`.PixbufLoader.close] should be
+ * called to end the stream and finalize everything.
+ * 
+ * The loader will emit three important signals throughout the process:
+ * 
+ *  - [signal`GdkPixbuf`.PixbufLoader::size-prepared] will be emitted as
+ *    soon as the image has enough information to determine the size of
+ *    the image to be used. If you want to scale the image while loading
+ *    it, you can call [method`GdkPixbuf`.PixbufLoader.set_size] in
+ *    response to this signal.
+ *  - [signal`GdkPixbuf`.PixbufLoader::area-prepared] will be emitted as
+ *    soon as the pixbuf of the desired has been allocated. You can obtain
+ *    the `GdkPixbuf` instance by calling [method`GdkPixbuf`.PixbufLoader.get_pixbuf].
+ *    If you want to use it, simply acquire a reference to it. You can
+ *    also call `gdk_pixbuf_loader_get_pixbuf()` later to get the same
+ *    pixbuf.
+ *  - [signal`GdkPixbuf`.PixbufLoader::area-updated] will be emitted every
+ *    time a region is updated. This way you can update a partially
+ *    completed image. Note that you do not know anything about the
+ *    completeness of an image from the updated area. For example, in an
+ *    interlaced image you will need to make several passes before the
+ *    image is done loading.
+ * 
+ * ## Loading an animation
+ * 
+ * Loading an animation is almost as easy as loading an image. Once the
+ * first [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been
+ * emitted, you can call [method`GdkPixbuf`.PixbufLoader.get_animation] to
+ * get the [class`GdkPixbuf`.PixbufAnimation] instance, and then call
+ * and [method`GdkPixbuf`.PixbufAnimation.get_iter] to get a
+ * [class`GdkPixbuf`.PixbufAnimationIter] to retrieve the pixbuf for the
+ * desired time stamp.
+ * @class 
+ */
+export class PixbufLoader extends GObject.Object {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader
+
+    static name: string
+    static $gtype: GObject.GType<PixbufLoader>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader
+
+    constructor(config?: PixbufLoader.ConstructorProperties) 
+    /**
+     * Creates a new pixbuf loader object.
+     * @constructor 
+     * @returns A newly-created pixbuf loader.
+     */
+    constructor() 
+    /**
+     * Creates a new pixbuf loader object.
+     * @constructor 
+     * @returns A newly-created pixbuf loader.
+     */
+    static new(): PixbufLoader
+    /**
+     * Creates a new pixbuf loader object that always attempts to parse
+     * image data as if it were an image of MIME type `mime_type,` instead of
+     * identifying the type automatically.
+     * 
+     * This function is useful if you want an error if the image isn't the
+     * expected MIME type; for loading image formats that can't be reliably
+     * identified by looking at the data; or if the user manually forces a
+     * specific MIME type.
+     * 
+     * The list of supported mime types depends on what image loaders
+     * are installed, but typically "image/png", "image/jpeg", "image/gif",
+     * "image/tiff" and "image/x-xpixmap" are among the supported mime types.
+     * To obtain the full list of supported mime types, call
+     * gdk_pixbuf_format_get_mime_types() on each of the #GdkPixbufFormat
+     * structs returned by gdk_pixbuf_get_formats().
+     * @constructor 
+     * @param mime_type the mime type to be loaded
+     * @returns A newly-created pixbuf loader.
+     */
+    static new_with_mime_type(mime_type: string | null): PixbufLoader
+    /**
+     * Creates a new pixbuf loader object that always attempts to parse
+     * image data as if it were an image of type `image_type,` instead of
+     * identifying the type automatically.
+     * 
+     * This function is useful if you want an error if the image isn't the
+     * expected type; for loading image formats that can't be reliably
+     * identified by looking at the data; or if the user manually forces
+     * a specific type.
+     * 
+     * The list of supported image formats depends on what image loaders
+     * are installed, but typically "png", "jpeg", "gif", "tiff" and
+     * "xpm" are among the supported formats. To obtain the full list of
+     * supported image formats, call gdk_pixbuf_format_get_name() on each
+     * of the #GdkPixbufFormat structs returned by gdk_pixbuf_get_formats().
+     * @constructor 
+     * @param image_type name of the image format to be loaded with the image
+     * @returns A newly-created pixbuf loader.
+     */
+    static new_with_type(image_type: string | null): PixbufLoader
+    _init(config?: PixbufLoader.ConstructorProperties): void
+}
+
+export module PixbufNonAnim {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends PixbufAnimation.ConstructorProperties {
+    }
+
+}
+
+export interface PixbufNonAnim {
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim
+
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+export class PixbufNonAnim extends PixbufAnimation {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim
+
+    static name: string
+    static $gtype: GObject.GType<PixbufNonAnim>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim
+
+    constructor(config?: PixbufNonAnim.ConstructorProperties) 
+    constructor(pixbuf: Pixbuf) 
+    static new(pixbuf: Pixbuf): PixbufNonAnim
+    _init(config?: PixbufNonAnim.ConstructorProperties): void
+}
+
+export module PixbufSimpleAnim {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends PixbufAnimation.ConstructorProperties {
+
+        // Own constructor properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim
+
+        /**
+         * Whether the animation should loop when it reaches the end.
+         */
+        loop?: boolean | null
+    }
+
+}
+
+export interface PixbufSimpleAnim {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim
+
+    /**
+     * Whether the animation should loop when it reaches the end.
+     */
+    loop: boolean
+
+    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim
+
+    /**
+     * Adds a new frame to `animation`. The `pixbuf` must
+     * have the dimensions specified when the animation
+     * was constructed.
+     * @param pixbuf the pixbuf to add
+     */
+    add_frame(pixbuf: Pixbuf): void
+    /**
+     * Gets whether `animation` should loop indefinitely when it reaches the end.
+     * @returns %TRUE if the animation loops forever, %FALSE otherwise
+     */
+    get_loop(): boolean
+    /**
+     * Sets whether `animation` should loop indefinitely when it reaches the end.
+     * @param loop whether to loop the animation
+     */
+    set_loop(loop: boolean): void
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim
+
+    connect(sigName: "notify::loop", callback: (($obj: PixbufSimpleAnim, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::loop", callback: (($obj: PixbufSimpleAnim, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::loop", ...args: any[]): void
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * An opaque struct representing a simple animation.
+ * @class 
+ */
+export class PixbufSimpleAnim extends PixbufAnimation {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim
+
+    static name: string
+    static $gtype: GObject.GType<PixbufSimpleAnim>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim
+
+    constructor(config?: PixbufSimpleAnim.ConstructorProperties) 
+    /**
+     * Creates a new, empty animation.
+     * @constructor 
+     * @param width the width of the animation
+     * @param height the height of the animation
+     * @param rate the speed of the animation, in frames per second
+     * @returns a newly allocated #GdkPixbufSimpleAnim
+     */
+    constructor(width: number, height: number, rate: number) 
+    /**
+     * Creates a new, empty animation.
+     * @constructor 
+     * @param width the width of the animation
+     * @param height the height of the animation
+     * @param rate the speed of the animation, in frames per second
+     * @returns a newly allocated #GdkPixbufSimpleAnim
+     */
+    static new(width: number, height: number, rate: number): PixbufSimpleAnim
+    _init(config?: PixbufSimpleAnim.ConstructorProperties): void
+}
+
+export module PixbufSimpleAnimIter {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends PixbufAnimationIter.ConstructorProperties {
+    }
+
+}
+
+export interface PixbufSimpleAnimIter {
+
+    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter
+
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+export class PixbufSimpleAnimIter extends PixbufAnimationIter {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter
+
+    static name: string
+    static $gtype: GObject.GType<PixbufSimpleAnimIter>
+
+    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter
+
+    constructor(config?: PixbufSimpleAnimIter.ConstructorProperties) 
+    _init(config?: PixbufSimpleAnimIter.ConstructorProperties): void
+}
+
+export interface PixbufAnimationClass {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationClass
+
+    /**
+     * the parent class
+     * @field 
+     */
+    parent_class: GObject.ObjectClass
+    is_static_image: (animation: PixbufAnimation) => boolean
+    get_static_image: (animation: PixbufAnimation) => Pixbuf
+    get_size: (animation: PixbufAnimation, width: number, height: number) => void
+    get_iter: (animation: PixbufAnimation, start_time: GLib.TimeVal | null) => PixbufAnimationIter
+}
+
+/**
+ * Modules supporting animations must derive a type from
+ * #GdkPixbufAnimation, providing suitable implementations of the
+ * virtual functions.
+ * @record 
+ */
+export abstract class PixbufAnimationClass {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationClass
+
+    static name: string
+}
+
+export interface PixbufAnimationIterClass {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIterClass
+
+    /**
+     * the parent class
+     * @field 
+     */
+    parent_class: GObject.ObjectClass
+    get_delay_time: (iter: PixbufAnimationIter) => number
+    get_pixbuf: (iter: PixbufAnimationIter) => Pixbuf
+    on_currently_loading_frame: (iter: PixbufAnimationIter) => boolean
+    advance: (iter: PixbufAnimationIter, current_time: GLib.TimeVal | null) => boolean
+}
+
+/**
+ * Modules supporting animations must derive a type from
+ * #GdkPixbufAnimationIter, providing suitable implementations of the
+ * virtual functions.
+ * @record 
+ */
+export abstract class PixbufAnimationIterClass {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIterClass
+
+    static name: string
+}
+
+export interface PixbufFormat {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat
+
+    /**
+     * the name of the image format
+     * @field 
+     */
+    name: string | null
+    /**
+     * the signature of the module
+     * @field 
+     */
+    signature: PixbufModulePattern
+    /**
+     * the message domain for the `description`
+     * @field 
+     */
+    domain: string | null
+    /**
+     * a description of the image format
+     * @field 
+     */
+    description: string | null
+    /**
+     * the MIME types for the image format
+     * @field 
+     */
+    mime_types: string[]
+    /**
+     * typical filename extensions for the
+     *   image format
+     * @field 
+     */
+    extensions: string[]
+    /**
+     * a combination of `GdkPixbufFormatFlags`
+     * @field 
+     */
+    flags: number
+    /**
+     * a boolean determining whether the loader is disabled`
+     * @field 
+     */
+    disabled: boolean
+    /**
+     * a string containing license information, typically set to
+     *   shorthands like "GPL", "LGPL", etc.
+     * @field 
+     */
+    license: string | null
+
+    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat
+
+    /**
+     * Creates a copy of `format`.
+     * @returns the newly allocated copy of a `GdkPixbufFormat`. Use   gdk_pixbuf_format_free() to free the resources when done
+     */
+    copy(): PixbufFormat
+    /**
+     * Frees the resources allocated when copying a `GdkPixbufFormat`
+     * using gdk_pixbuf_format_copy()
+     */
+    free(): void
+    /**
+     * Returns a description of the format.
+     * @returns a description of the format.
+     */
+    get_description(): string | null
+    /**
+     * Returns the filename extensions typically used for files in the
+     * given format.
+     * @returns an array of   filename extensions
+     */
+    get_extensions(): string[]
+    /**
+     * Returns information about the license of the image loader for the format.
+     * 
+     * The returned string should be a shorthand for a well known license, e.g.
+     * "LGPL", "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license.
+     * @returns a string describing the license of the pixbuf format
+     */
+    get_license(): string | null
+    /**
+     * Returns the mime types supported by the format.
+     * @returns an array of mime types
+     */
+    get_mime_types(): string[]
+    /**
+     * Returns the name of the format.
+     * @returns the name of the format.
+     */
+    get_name(): string | null
+    /**
+     * Returns whether this image format is disabled.
+     * 
+     * See gdk_pixbuf_format_set_disabled().
+     * @returns whether this image format is disabled.
+     */
+    is_disabled(): boolean
+    /**
+     * Returns `TRUE` if the save option specified by `option_key` is supported when
+     * saving a pixbuf using the module implementing `format`.
+     * 
+     * See gdk_pixbuf_save() for more information about option keys.
+     * @param option_key the name of an option
+     * @returns `TRUE` if the specified option is supported
+     */
+    is_save_option_supported(option_key: string | null): boolean
+    /**
+     * Returns whether this image format is scalable.
+     * 
+     * If a file is in a scalable format, it is preferable to load it at
+     * the desired size, rather than loading it at the default size and
+     * scaling the resulting pixbuf to the desired size.
+     * @returns whether this image format is scalable.
+     */
+    is_scalable(): boolean
+    /**
+     * Returns whether pixbufs can be saved in the given format.
+     * @returns whether pixbufs can be saved in the given format.
+     */
+    is_writable(): boolean
+    /**
+     * Disables or enables an image format.
+     * 
+     * If a format is disabled, GdkPixbuf won't use the image loader for
+     * this format to load images.
+     * 
+     * Applications can use this to avoid using image loaders with an
+     * inappropriate license, see gdk_pixbuf_format_get_license().
+     * @param disabled `TRUE` to disable the format `format`
+     */
+    set_disabled(disabled: boolean): void
+}
+
+/**
+ * A `GdkPixbufFormat` contains information about the image format accepted
+ * by a module.
+ * 
+ * Only modules should access the fields directly, applications should
+ * use the `gdk_pixbuf_format_*` family of functions.
+ * @record 
+ */
+export class PixbufFormat {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat
+
+    static name: string
+}
+
+export interface PixbufLoaderClass {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufLoaderClass
+
+    parent_class: GObject.ObjectClass
+    size_prepared: (loader: PixbufLoader, width: number, height: number) => void
+    area_prepared: (loader: PixbufLoader) => void
+    area_updated: (loader: PixbufLoader, x: number, y: number, width: number, height: number) => void
+    closed: (loader: PixbufLoader) => void
+}
+
+export abstract class PixbufLoaderClass {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoaderClass
+
+    static name: string
+}
+
+export interface PixbufModule {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufModule
+
+    /**
+     * the name of the module, usually the same as the
+     *  usual file extension for images of this type, eg. "xpm", "jpeg" or "png".
+     * @field 
+     */
+    module_name: string | null
+    /**
+     * the path from which the module is loaded.
+     * @field 
+     */
+    module_path: string | null
+    /**
+     * the loaded `GModule`.
+     * @field 
+     */
+    module: GModule.Module
+    /**
+     * a `GdkPixbufFormat` holding information about the module.
+     * @field 
+     */
+    info: PixbufFormat
+    stop_load: (context: any) => boolean
+    load_increment: (context: any, buf: number, size: number) => boolean
+    save: (f: any, pixbuf: Pixbuf, param_keys: string | null, param_values: string | null) => boolean
+    is_save_option_supported: (option_key: string | null) => boolean
+}
+
+/**
+ * A `GdkPixbufModule` contains the necessary functions to load and save
+ * images in a certain file format.
+ * 
+ * If `GdkPixbuf` has been compiled with `GModule` support, it can be extended
+ * by modules which can load (and perhaps also save) new image and animation
+ * formats.
+ * 
+ * ## Implementing modules
+ * 
+ * The `GdkPixbuf` interfaces needed for implementing modules are contained in
+ * `gdk-pixbuf-io.h` (and `gdk-pixbuf-animation.h` if the module supports
+ * animations). They are not covered by the same stability guarantees as the
+ * regular GdkPixbuf API. To underline this fact, they are protected by the
+ * `GDK_PIXBUF_ENABLE_BACKEND` pre-processor symbol.
+ * 
+ * Each loadable module must contain a `GdkPixbufModuleFillVtableFunc` function
+ * named `fill_vtable`, which will get called when the module
+ * is loaded and must set the function pointers of the `GdkPixbufModule`.
+ * 
+ * In order to make format-checking work before actually loading the modules
+ * (which may require calling `dlopen` to load image libraries), modules export
+ * their signatures (and other information) via the `fill_info` function. An
+ * external utility, `gdk-pixbuf-query-loaders`, uses this to create a text
+ * file containing a list of all available loaders and  their signatures.
+ * This file is then read at runtime by `GdkPixbuf` to obtain the list of
+ * available loaders and their signatures.
+ * 
+ * Modules may only implement a subset of the functionality available via
+ * `GdkPixbufModule`. If a particular functionality is not implemented, the
+ * `fill_vtable` function will simply not set the corresponding
+ * function pointers of the `GdkPixbufModule` structure. If a module supports
+ * incremental loading (i.e. provides `begin_load`, `stop_load` and
+ * `load_increment`), it doesn't have to implement `load`, since `GdkPixbuf`
+ * can supply a generic `load` implementation wrapping the incremental loading.
+ * 
+ * ## Installing modules
+ * 
+ * Installing a module is a two-step process:
+ * 
+ *  - copy the module file(s) to the loader directory (normally
+ *    `$libdir/gdk-pixbuf-2.0/$version/loaders`, unless overridden by the
+ *    environment variable `GDK_PIXBUF_MODULEDIR`)
+ *  - call `gdk-pixbuf-query-loaders` to update the module file (normally
+ *    `$libdir/gdk-pixbuf-2.0/$version/loaders.cache`, unless overridden
+ *    by the environment variable `GDK_PIXBUF_MODULE_FILE`)
+ * @record 
+ */
+export class PixbufModule {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufModule
+
+    static name: string
+}
+
+export interface PixbufModulePattern {
+
+    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufModulePattern
+
+    /**
+     * the prefix for this pattern
+     * @field 
+     */
+    prefix: string | null
+    /**
+     * mask containing bytes which modify how the prefix is matched against
+     *  test data
+     * @field 
+     */
+    mask: string | null
+    /**
+     * relevance of this pattern
+     * @field 
+     */
+    relevance: number
+}
+
+/**
+ * The signature prefix for a module.
+ * 
+ * The signature of a module is a set of prefixes. Prefixes are encoded as
+ * pairs of ordinary strings, where the second string, called the mask, if
+ * not `NULL`, must be of the same length as the first one and may contain
+ * ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched,
+ * not matched, "don't-care"-bytes, zeros and non-zeros, respectively.
+ * 
+ * Each prefix has an associated integer that describes the relevance of
+ * the prefix, with 0 meaning a mismatch and 100 a "perfect match".
+ * 
+ * Starting with gdk-pixbuf 2.8, the first byte of the mask may be '*',
+ * indicating an unanchored pattern that matches not only at the beginning,
+ * but also in the middle. Versions prior to 2.8 will interpret the '*'
+ * like an 'x'.
+ * 
+ * The signature of a module is stored as an array of
+ * `GdkPixbufModulePatterns`. The array is terminated by a pattern
+ * where the `prefix` is `NULL`.
+ * 
+ * ```c
+ * GdkPixbufModulePattern *signature[] = {
+ *   { "abcdx", " !x z", 100 },
+ *   { "bla", NULL,  90 },
+ *   { NULL, NULL, 0 }
+ * };
+ * ```
+ * 
+ * In the example above, the signature matches e.g. "auud\0" with
+ * relevance 100, and "blau" with relevance 90.
+ * @record 
+ */
+export class PixbufModulePattern {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufModulePattern
+
+    static name: string
+}
+
+export interface PixbufSimpleAnimClass {
+}
+
+export abstract class PixbufSimpleAnimClass {
+
+    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimClass
+
+    static name: string
+}
+
+/**
+ * Name of the imported GIR library
+ * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+ */
+export const __name__: string
+/**
+ * Version of the imported GIR library
+ * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+ */
+export const __version__: string
+// END