@react-gnome/gjs-esm-types/src/@types/Gjs/GdkPixbuf-2.0.d.ts

TypeScript module declarations for GJS ESM modules.

/*
 * 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 itself or create a bug report on https://github.com/gjsify/ts-for-gjs
 */
import type Gio from "gi://Gio?version=2.0";
import type GObject from "gi://GObject?version=2.0";
import type GLib from "gi://GLib?version=2.0";
import type GModule from "gi://GModule?version=2.0";

declare module "gi://GdkPixbuf?version=2.0" {
  /**
   * This enumeration defines the color spaces that are supported by
   * the gdk-pixbuf library.
   *
   * Currently only RGB is supported.
   */
  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.
   */
  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.
   */
  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.
   */
  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.
   */
  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
   */
  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.
   */
  const PIXBUF_MAJOR: number;
  /**
   * Micro version of gdk-pixbuf library, that is the "2" in
   * "0.8.2" for example.
   */
  const PIXBUF_MICRO: number;
  /**
   * Minor version of gdk-pixbuf library, that is the "8" in
   * "0.8.2" for example.
   */
  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`.
   */
  const PIXBUF_VERSION: string | null;
  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.
   */
  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.
   */
  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.
   */
  interface PixbufModuleFillVtableFunc {
    (module: PixbufModule): void;
  }

  /**
   * Incrementally loads a buffer into the image data.
   * @callback
   * @param context the state object created by [callback`GdkPixbuf`.PixbufModuleBeginLoadFunc]
   * @param buf the data to load
   * @returns `TRUE` if the incremental load was successful
   */
  interface PixbufModuleIncrementLoadFunc {
    (context: any | null, buf: Uint8Array): boolean;
  }

  /**
   * Loads a file from a standard C file stream into a new `GdkPixbufAnimation`.
   *
   * In case of error, this function should return `NULL` and set the `error` argument.
   * @callback
   * @param f the file stream from which the image should be loaded
   * @returns a newly created `GdkPixbufAnimation` for the contents of the file
   */
  interface PixbufModuleLoadAnimationFunc {
    (f: any | null): PixbufAnimation;
  }

  /**
   * Loads a file from a standard C file stream into a new `GdkPixbuf`.
   *
   * In case of error, this function should return `NULL` and set the `error` argument.
   * @callback
   * @param f the file stream from which the image should be loaded
   * @returns a newly created `GdkPixbuf` for the contents of the file
   */
  interface PixbufModuleLoadFunc {
    (f: any | null): Pixbuf;
  }

  /**
   * Loads XPM data into a new `GdkPixbuf`.
   * @callback
   * @param data the XPM data
   * @returns a newly created `GdkPixbuf` for the XPM data
   */
  interface PixbufModuleLoadXpmDataFunc {
    (data: string[]): Pixbuf;
  }

  /**
   * 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.
   */
  interface PixbufModulePreparedFunc {
    (pixbuf: Pixbuf, anim: PixbufAnimation): void;
  }

  /**
   * Saves a `GdkPixbuf` into a standard C file stream.
   *
   * The optional `param_keys` and `param_values` arrays contain the keys and
   * values (in the same order) for attributes to be saved alongside the image
   * data.
   * @callback
   * @param f the file stream into which the image should be saved
   * @param pixbuf the image to save
   * @param param_keys parameter keys to save
   * @param param_values parameter values to save
   * @returns `TRUE` on success; in case of failure, `FALSE` is returned and   the `error` is set
   */
  interface PixbufModuleSaveFunc {
    (
      f: any | null,
      pixbuf: Pixbuf,
      param_keys: string[] | null,
      param_values: string[] | null
    ): boolean;
  }

  /**
   * Checks whether the given `option_key` is supported when saving.
   * @callback
   * @param option_key the option key to check
   * @returns `TRUE` if the option is supported
   */
  interface PixbufModuleSaveOptionSupportedFunc {
    (option_key: string | null): boolean;
  }

  /**
   * 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
   */
  interface PixbufModuleSizeFunc {
    (width: number, height: number): void;
  }

  /**
   * Finalizes the image loading state.
   *
   * This function is called on success and error states.
   * @callback
   * @param context the state object created by [callback`GdkPixbuf`.PixbufModuleBeginLoadFunc]
   * @returns `TRUE` if the loading operation was successful
   */
  interface PixbufModuleStopLoadFunc {
    (context: any | null): boolean;
  }

  /**
   * 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.
   */
  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
   */
  interface PixbufSaveFunc {
    (buf: Uint8Array): boolean;
  }

  module Pixbuf {
    // Constructor properties interface

    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;
    }
  }

  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
   */
  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 d