@react-gnome/gjs-esm-types/src/@types/Gjs/Gsk-4.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 Graphene from "gi://Graphene?version=1.0";
import type GObject from "gi://GObject?version=2.0";
import type GLib from "gi://GLib?version=2.0";
import type Gdk from "gi://Gdk?version=4.0";
import type cairo from "gi://cairo?version=1.0";
import type PangoCairo from "gi://PangoCairo?version=1.0";
import type Pango from "gi://Pango?version=1.0";
import type HarfBuzz from "gi://HarfBuzz?version=0.0";
import type freetype2 from "gi://freetype2?version=2.0";
import type Gio from "gi://Gio?version=2.0";
import type GdkPixbuf from "gi://GdkPixbuf?version=2.0";
import type GModule from "gi://GModule?version=2.0";

declare module "gi://Gsk?version=4.0" {
  /**
   * The blend modes available for render nodes.
   *
   * The implementation of each blend mode is deferred to the
   * rendering pipeline.
   *
   * See <https://www.w3.org/TR/compositing-1/#blending> for more information
   * on blending and blend modes.
   */
  enum BlendMode {
    /**
     * The default blend mode, which specifies no blending
     */
    DEFAULT,
    /**
     * The source color is multiplied by the destination
     *   and replaces the destination
     */
    MULTIPLY,
    /**
     * Multiplies the complements of the destination and source
     *   color values, then complements the result.
     */
    SCREEN,
    /**
     * Multiplies or screens the colors, depending on the
     *   destination color value. This is the inverse of hard-list
     */
    OVERLAY,
    /**
     * Selects the darker of the destination and source colors
     */
    DARKEN,
    /**
     * Selects the lighter of the destination and source colors
     */
    LIGHTEN,
    /**
     * Brightens the destination color to reflect the source color
     */
    COLOR_DODGE,
    /**
     * Darkens the destination color to reflect the source color
     */
    COLOR_BURN,
    /**
     * Multiplies or screens the colors, depending on the source color value
     */
    HARD_LIGHT,
    /**
     * Darkens or lightens the colors, depending on the source color value
     */
    SOFT_LIGHT,
    /**
     * Subtracts the darker of the two constituent colors from the lighter color
     */
    DIFFERENCE,
    /**
     * Produces an effect similar to that of the difference mode but lower in contrast
     */
    EXCLUSION,
    /**
     * Creates a color with the hue and saturation of the source color and the luminosity of the destination color
     */
    COLOR,
    /**
     * Creates a color with the hue of the source color and the saturation and luminosity of the destination color
     */
    HUE,
    /**
     * Creates a color with the saturation of the source color and the hue and luminosity of the destination color
     */
    SATURATION,
    /**
     * Creates a color with the luminosity of the source color and the hue and saturation of the destination color
     */
    LUMINOSITY,
  }

  /**
   * The corner indices used by `GskRoundedRect`.
   */
  enum Corner {
    /**
     * The top left corner
     */
    TOP_LEFT,
    /**
     * The top right corner
     */
    TOP_RIGHT,
    /**
     * The bottom right corner
     */
    BOTTOM_RIGHT,
    /**
     * The bottom left corner
     */
    BOTTOM_LEFT,
  }

  /**
   * This defines the types of the uniforms that `GskGLShaders`
   * declare.
   *
   * It defines both what the type is called in the GLSL shader
   * code, and what the corresponding C type is on the Gtk side.
   */
  enum GLUniformType {
    /**
     * No type, used for uninitialized or unspecified values.
     */
    NONE,
    /**
     * A float uniform
     */
    FLOAT,
    /**
     * A GLSL int / gint32 uniform
     */
    INT,
    /**
     * A GLSL uint / guint32 uniform
     */
    UINT,
    /**
     * A GLSL bool / gboolean uniform
     */
    BOOL,
    /**
     * A GLSL vec2 / graphene_vec2_t uniform
     */
    VEC2,
    /**
     * A GLSL vec3 / graphene_vec3_t uniform
     */
    VEC3,
    /**
     * A GLSL vec4 / graphene_vec4_t uniform
     */
    VEC4,
  }

  /**
   * The type of a node determines what the node is rendering.
   */
  enum RenderNodeType {
    /**
     * Error type. No node will ever have this type.
     */
    NOT_A_RENDER_NODE,
    /**
     * A node containing a stack of children
     */
    CONTAINER_NODE,
    /**
     * A node drawing a `cairo_surface_t`
     */
    CAIRO_NODE,
    /**
     * A node drawing a single color rectangle
     */
    COLOR_NODE,
    /**
     * A node drawing a linear gradient
     */
    LINEAR_GRADIENT_NODE,
    /**
     * A node drawing a repeating linear gradient
     */
    REPEATING_LINEAR_GRADIENT_NODE,
    /**
     * A node drawing a radial gradient
     */
    RADIAL_GRADIENT_NODE,
    /**
     * A node drawing a repeating radial gradient
     */
    REPEATING_RADIAL_GRADIENT_NODE,
    /**
     * A node drawing a conic gradient
     */
    CONIC_GRADIENT_NODE,
    /**
     * A node stroking a border around an area
     */
    BORDER_NODE,
    /**
     * A node drawing a `GdkTexture`
     */
    TEXTURE_NODE,
    /**
     * A node drawing an inset shadow
     */
    INSET_SHADOW_NODE,
    /**
     * A node drawing an outset shadow
     */
    OUTSET_SHADOW_NODE,
    /**
     * A node that renders its child after applying a matrix transform
     */
    TRANSFORM_NODE,
    /**
     * A node that changes the opacity of its child
     */
    OPACITY_NODE,
    /**
     * A node that applies a color matrix to every pixel
     */
    COLOR_MATRIX_NODE,
    /**
     * A node that repeats the child's contents
     */
    REPEAT_NODE,
    /**
     * A node that clips its child to a rectangular area
     */
    CLIP_NODE,
    /**
     * A node that clips its child to a rounded rectangle
     */
    ROUNDED_CLIP_NODE,
    /**
     * A node that draws a shadow below its child
     */
    SHADOW_NODE,
    /**
     * A node that blends two children together
     */
    BLEND_NODE,
    /**
     * A node that cross-fades between two children
     */
    CROSS_FADE_NODE,
    /**
     * A node containing a glyph string
     */
    TEXT_NODE,
    /**
     * A node that applies a blur
     */
    BLUR_NODE,
    /**
     * Debug information that does not affect the rendering
     */
    DEBUG_NODE,
    /**
     * A node that uses OpenGL fragment shaders to render
     */
    GL_SHADER_NODE,
  }

  /**
   * The filters used when scaling texture data.
   *
   * The actual implementation of each filter is deferred to the
   * rendering pipeline.
   */
  enum ScalingFilter {
    /**
     * linear interpolation filter
     */
    LINEAR,
    /**
     * nearest neighbor interpolation filter
     */
    NEAREST,
    /**
     * linear interpolation along each axis,
     *   plus mipmap generation, with linear interpolation along the mipmap
     *   levels
     */
    TRILINEAR,
  }

  /**
   * Errors that can happen during (de)serialization.
   */
  enum SerializationError {
    /**
     * The format can not be identified
     */
    UNSUPPORTED_FORMAT,
    /**
     * The version of the data is not
     *   understood
     */
    UNSUPPORTED_VERSION,
    /**
     * The given data may not exist in
     *   a proper serialization
     */
    INVALID_DATA,
  }

  /**
   * The categories of matrices relevant for GSK and GTK.
   *
   * Note that any category includes matrices of all later categories.
   * So if you want to for example check if a matrix is a 2D matrix,
   * `category >= GSK_TRANSFORM_CATEGORY_2D` is the way to do this.
   *
   * Also keep in mind that rounding errors may cause matrices to not
   * conform to their categories. Otherwise, matrix operations done via
   * multiplication will not worsen categories. So for the matrix
   * multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`.
   */
  enum TransformCategory {
    /**
     * The category of the matrix has not been
     *   determined.
     */
    UNKNOWN,
    /**
     * Analyzing the matrix concluded that it does
     *   not fit in any other category.
     */
    ANY,
    /**
     * The matrix is a 3D matrix. This means that
     *   the w column (the last column) has the values (0, 0, 0, 1).
     */
    TODO_3D,
    /**
     * The matrix is a 2D matrix. This is equivalent
     *   to graphene_matrix_is_2d() returning %TRUE. In particular, this
     *   means that Cairo can deal with the matrix.
     */
    TODO_2D,
    /**
     * The matrix is a combination of 2D scale
     *   and 2D translation operations. In particular, this means that any
     *   rectangle can be transformed exactly using this matrix.
     */
    TODO_2D_AFFINE,
    /**
     * The matrix is a 2D translation.
     */
    TODO_2D_TRANSLATE,
    /**
     * The matrix is the identity matrix.
     */
    IDENTITY,
  }

  function serialization_error_quark(): GLib.Quark;
  /**
   * Parses the given `string` into a transform and puts it in
   * `out_transform`.
   *
   * Strings printed via [method`Gsk`.Transform.to_string]
   * can be read in again successfully using this function.
   *
   * If `string` does not describe a valid transform, %FALSE is
   * returned and %NULL is put in `out_transform`.
   * @param string the string to parse
   * @returns %TRUE if @string described a valid transform.
   */
  function transform_parse(
    string: string | null
  ): [/* returnType */ boolean, /* out_transform */ Transform];
  /**
   * Retrieves the `GskRenderNode` stored inside the given `value`, and acquires
   * a reference to it.
   * @param value a [struct`GObject`.Value] initialized with type `GSK_TYPE_RENDER_NODE`
   * @returns a `GskRenderNode`
   */
  function value_dup_render_node(value: any): RenderNode | null;
  /**
   * Retrieves the `GskRenderNode` stored inside the given `value`.
   * @param value a `GValue` initialized with type `GSK_TYPE_RENDER_NODE`
   * @returns a `GskRenderNode`
   */
  function value_get_render_node(value: any): RenderNode | null;
  /**
   * Stores the given `GskRenderNode` inside `value`.
   *
   * The [struct`GObject`.Value] will acquire a reference to the `node`.
   * @param value a [struct`GObject`.Value] initialized with type `GSK_TYPE_RENDER_NODE`
   * @param node a `GskRenderNode`
   */
  function value_set_render_node(value: any, node: RenderNode): void;
  /**
   * Stores the given `GskRenderNode` inside `value`.
   *
   * This function transfers the ownership of the `node` to the `GValue`.
   * @param value a [struct`GObject`.Value] initialized with type `GSK_TYPE_RENDER_NODE`
   * @param node a `GskRenderNode`
   */
  function value_take_render_node(value: any, node: RenderNode | null): void;
  /**
   * Type of callback that is called when an error occurs
   * during node deserialization.
   * @callback
   * @param start start of the error location
   * @param end end of the error location
   * @param error the error
   */
  interface ParseErrorFunc {
    (start: ParseLocation, end: ParseLocation, error: GLib.Error): void;
  }

  interface BlendNode {
    // Owm methods of Gsk-4.0.Gsk.BlendNode

    /**
     * Retrieves the blend mode used by `node`.
     * @returns the blend mode
     */
    get_blend_mode(): BlendMode;
    /**
     * Retrieves the bottom `GskRenderNode` child of the `node`.
     * @returns the bottom child node
     */
    get_bottom_child(): RenderNode;
    /**
     * Retrieves the top `GskRenderNode` child of the `node`.
     * @returns the top child node
     */
    get_top_child(): RenderNode;
  }

  /**
   * A render node applying a blending function between its two child nodes.
   * @class
   */
  class BlendNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.BlendNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.BlendNode

    /**
     * Creates a `GskRenderNode` that will use `blend_mode` to blend the `top`
     * node onto the `bottom` node.
     * @constructor
     * @param bottom The bottom node to be drawn
     * @param top The node to be blended onto the `bottom` node
     * @param blend_mode The blend mode to use
     * @returns A new `GskRenderNode`
     */
    constructor(bottom: RenderNode, top: RenderNode, blend_mode: BlendMode);
    /**
     * Creates a `GskRenderNode` that will use `blend_mode` to blend the `top`
     * node onto the `bottom` node.
     * @constructor
     * @param bottom The bottom node to be drawn
     * @param top The node to be blended onto the `bottom` node
     * @param blend_mode The blend mode to use
     * @returns A new `GskRenderNode`
     */
    static new(
      bottom: RenderNode,
      top: RenderNode,
      blend_mode: BlendMode
    ): BlendNode;
  }

  interface BlurNode {
    // Owm methods of Gsk-4.0.Gsk.BlurNode

    /**
     * Retrieves the child `GskRenderNode` of the blur `node`.
     * @returns the blurred child node
     */
    get_child(): RenderNode;
    /**
     * Retrieves the blur radius of the `node`.
     * @returns the blur radius
     */
    get_radius(): number;
  }

  /**
   * A render node applying a blur effect to its single child.
   * @class
   */
  class BlurNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.BlurNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.BlurNode

    /**
     * Creates a render node that blurs the child.
     * @constructor
     * @param child the child node to blur
     * @param radius the blur radius. Must be positive
     * @returns a new `GskRenderNode`
     */
    constructor(child: RenderNode, radius: number);
    /**
     * Creates a render node that blurs the child.
     * @constructor
     * @param child the child node to blur
     * @param radius the blur radius. Must be positive
     * @returns a new `GskRenderNode`
     */
    static new(child: RenderNode, radius: number): BlurNode;
  }

  interface BorderNode {
    // Owm methods of Gsk-4.0.Gsk.BorderNode

    /**
     * Retrieves the colors of the border.
     * @returns an array of 4 `GdkRGBA` structs     for the top, right, bottom and left color of the border
     */
    get_colors(): Gdk.RGBA;
    /**
     * Retrieves the outline of the border.
     * @returns the outline of the border
     */
    get_outline(): RoundedRect;
    /**
     * Retrieves the stroke widths of the border.
     * @returns an array of 4 floats   for the top, right, bottom and left stroke width of the border,   respectively
     */
    get_widths(): number[];
  }

  /**
   * A render node for a border.
   * @class
   */
  class BorderNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.BorderNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.BorderNode

    /**
     * Creates a `GskRenderNode` that will stroke a border rectangle inside the
     * given `outline`.
     *
     * The 4 sides of the border can have different widths and colors.
     * @constructor
     * @param outline a `GskRoundedRect` describing the outline of the border
     * @param border_width the stroke width of the border on     the top, right, bottom and left side respectively.
     * @param border_color the color used on the top, right,     bottom and left side.
     * @returns A new `GskRenderNode`
     */
    constructor(
      outline: RoundedRect,
      border_width: number[],
      border_color: Gdk.RGBA[]
    );
    /**
     * Creates a `GskRenderNode` that will stroke a border rectangle inside the
     * given `outline`.
     *
     * The 4 sides of the border can have different widths and colors.
     * @constructor
     * @param outline a `GskRoundedRect` describing the outline of the border
     * @param border_width the stroke width of the border on     the top, right, bottom and left side respectively.
     * @param border_color the color used on the top, right,     bottom and left side.
     * @returns A new `GskRenderNode`
     */
    static new(
      outline: RoundedRect,
      border_width: number[],
      border_color: Gdk.RGBA[]
    ): BorderNode;
  }

  module BroadwayRenderer {
    // Constructor properties interface

    type ConstructorProperties = Renderer.ConstructorProperties;
  }

  interface BroadwayRenderer {
    // Class property signals of Gsk-4.0.Gsk.BroadwayRenderer

    connect(
      sigName: "notify::realized",
      callback: ($obj: BroadwayRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::realized",
      callback: ($obj: BroadwayRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::realized", ...args: any[]): void;
    connect(
      sigName: "notify::surface",
      callback: ($obj: BroadwayRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::surface",
      callback: ($obj: BroadwayRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::surface", ...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;
  }

  class BroadwayRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.BroadwayRenderer

    static name: string;
    static $gtype: GObject.GType<BroadwayRenderer>;

    // Constructors of Gsk-4.0.Gsk.BroadwayRenderer

    constructor(config?: BroadwayRenderer.ConstructorProperties);
    /**
     * Creates a new Broadway renderer.
     *
     * The Broadway renderer is the default renderer for the broadway backend.
     * It will only work with broadway surfaces, otherwise it will fail the
     * call to gsk_renderer_realize().
     *
     * This function is only available when GTK was compiled with Broadway
     * support.
     * @constructor
     * @returns a new Broadway renderer.
     */
    constructor();
    /**
     * Creates a new Broadway renderer.
     *
     * The Broadway renderer is the default renderer for the broadway backend.
     * It will only work with broadway surfaces, otherwise it will fail the
     * call to gsk_renderer_realize().
     *
     * This function is only available when GTK was compiled with Broadway
     * support.
     * @constructor
     * @returns a new Broadway renderer.
     */
    static new(): BroadwayRenderer;
    _init(config?: BroadwayRenderer.ConstructorProperties): void;
  }

  interface CairoNode {
    // Owm methods of Gsk-4.0.Gsk.CairoNode

    /**
     * Creates a Cairo context for drawing using the surface associated
     * to the render node.
     *
     * If no surface exists yet, a surface will be created optimized for
     * rendering to `renderer`.
     * @returns a Cairo context used for drawing; use   cairo_destroy() when done drawing
     */
    get_draw_context(): cairo.Context;
    /**
     * Retrieves the Cairo surface used by the render node.
     * @returns a Cairo surface
     */
    get_surface(): cairo.Surface;
  }

  /**
   * A render node for a Cairo surface.
   * @class
   */
  class CairoNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.CairoNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.CairoNode

    /**
     * Creates a `GskRenderNode` that will render a cairo surface
     * into the area given by `bounds`.
     *
     * You can draw to the cairo surface using [method`Gsk`.CairoNode.get_draw_context].
     * @constructor
     * @param bounds the rectangle to render to
     * @returns A new `GskRenderNode`
     */
    constructor(bounds: Graphene.Rect);
    /**
     * Creates a `GskRenderNode` that will render a cairo surface
     * into the area given by `bounds`.
     *
     * You can draw to the cairo surface using [method`Gsk`.CairoNode.get_draw_context].
     * @constructor
     * @param bounds the rectangle to render to
     * @returns A new `GskRenderNode`
     */
    static new(bounds: Graphene.Rect): CairoNode;
  }

  module CairoRenderer {
    // Constructor properties interface

    type ConstructorProperties = Renderer.ConstructorProperties;
  }

  interface CairoRenderer {
    // Class property signals of Gsk-4.0.Gsk.CairoRenderer

    connect(
      sigName: "notify::realized",
      callback: ($obj: CairoRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::realized",
      callback: ($obj: CairoRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::realized", ...args: any[]): void;
    connect(
      sigName: "notify::surface",
      callback: ($obj: CairoRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::surface",
      callback: ($obj: CairoRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::surface", ...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 GSK renderer that is using cairo.
   *
   * Since it is using cairo, this renderer cannot support
   * 3D transformations.
   * @class
   */
  class CairoRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.CairoRenderer

    static name: string;
    static $gtype: GObject.GType<CairoRenderer>;

    // Constructors of Gsk-4.0.Gsk.CairoRenderer

    constructor(config?: CairoRenderer.ConstructorProperties);
    /**
     * Creates a new Cairo renderer.
     *
     * The Cairo renderer is the fallback renderer drawing in ways similar
     * to how GTK 3 drew its content. Its primary use is as comparison tool.
     *
     * The Cairo renderer is incomplete. It cannot render 3D transformed
     * content and will instead render an error marker. Its usage should be
     * avoided.
     * @constructor
     * @returns a new Cairo renderer.
     */
    constructor();
    /**
     * Creates a new Cairo renderer.
     *
     * The Cairo renderer is the fallback renderer drawing in ways similar
     * to how GTK 3 drew its content. Its primary use is as comparison tool.
     *
     * The Cairo renderer is incomplete. It cannot render 3D transformed
     * content and will instead render an error marker. Its usage should be
     * avoided.
     * @constructor
     * @returns a new Cairo renderer.
     */
    static new(): CairoRenderer;
    _init(config?: CairoRenderer.ConstructorProperties): void;
  }

  interface ClipNode {
    // Owm methods of Gsk-4.0.Gsk.ClipNode

    /**
     * Gets the child node that is getting clipped by the given `node`.
     * @returns The child that is getting clipped
     */
    get_child(): RenderNode;
    /**
     * Retrieves the clip rectangle for `node`.
     * @returns a clip rectangle
     */
    get_clip(): Graphene.Rect;
  }

  /**
   * A render node applying a rectangular clip to its single child node.
   * @class
   */
  class ClipNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ClipNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.ClipNode

    /**
     * Creates a `GskRenderNode` that will clip the `child` to the area
     * given by `clip`.
     * @constructor
     * @param child The node to draw
     * @param clip The clip to apply
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, clip: Graphene.Rect);
    /**
     * Creates a `GskRenderNode` that will clip the `child` to the area
     * given by `clip`.
     * @constructor
     * @param child The node to draw
     * @param clip The clip to apply
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, clip: Graphene.Rect): ClipNode;
  }

  interface ColorMatrixNode {
    // Owm methods of Gsk-4.0.Gsk.ColorMatrixNode

    /**
     * Gets the child node that is getting its colors modified by the given `node`.
     * @returns The child that is getting its colors modified
     */
    get_child(): RenderNode;
    /**
     * Retrieves the color matrix used by the `node`.
     * @returns a 4x4 color matrix
     */
    get_color_matrix(): Graphene.Matrix;
    /**
     * Retrieves the color offset used by the `node`.
     * @returns a color vector
     */
    get_color_offset(): Graphene.Vec4;
  }

  /**
   * A render node controlling the color matrix of its single child node.
   * @class
   */
  class ColorMatrixNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ColorMatrixNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.ColorMatrixNode

    /**
     * Creates a `GskRenderNode` that will drawn the `child` with
     * `color_matrix`.
     *
     * In particular, the node will transform the operation
     *
     *     pixel = color_matrix * pixel + color_offset
     *
     * for every pixel.
     * @constructor
     * @param child The node to draw
     * @param color_matrix The matrix to apply
     * @param color_offset Values to add to the color
     * @returns A new `GskRenderNode`
     */
    constructor(
      child: RenderNode,
      color_matrix: Graphene.Matrix,
      color_offset: Graphene.Vec4
    );
    /**
     * Creates a `GskRenderNode` that will drawn the `child` with
     * `color_matrix`.
     *
     * In particular, the node will transform the operation
     *
     *     pixel = color_matrix * pixel + color_offset
     *
     * for every pixel.
     * @constructor
     * @param child The node to draw
     * @param color_matrix The matrix to apply
     * @param color_offset Values to add to the color
     * @returns A new `GskRenderNode`
     */
    static new(
      child: RenderNode,
      color_matrix: Graphene.Matrix,
      color_offset: Graphene.Vec4
    ): ColorMatrixNode;
  }

  interface ColorNode {
    // Owm methods of Gsk-4.0.Gsk.ColorNode

    /**
     * Retrieves the color of the given `node`.
     * @returns the color of the node
     */
    get_color(): Gdk.RGBA;
  }

  /**
   * A render node for a solid color.
   * @class
   */
  class ColorNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ColorNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.ColorNode

    /**
     * Creates a `GskRenderNode` that will render the color specified by `rgba` into
     * the area given by `bounds`.
     * @constructor
     * @param rgba a `GdkRGBA` specifying a color
     * @param bounds the rectangle to render the color into
     * @returns A new `GskRenderNode`
     */
    constructor(rgba: Gdk.RGBA, bounds: Graphene.Rect);
    /**
     * Creates a `GskRenderNode` that will render the color specified by `rgba` into
     * the area given by `bounds`.
     * @constructor
     * @param rgba a `GdkRGBA` specifying a color
     * @param bounds the rectangle to render the color into
     * @returns A new `GskRenderNode`
     */
    static new(rgba: Gdk.RGBA, bounds: Graphene.Rect): ColorNode;
  }

  interface ConicGradientNode {
    // Owm methods of Gsk-4.0.Gsk.ConicGradientNode

    /**
     * Retrieves the angle for the gradient in radians, normalized in [0, 2 * PI].
     *
     * The angle is starting at the top and going clockwise, as expressed
     * in the css specification:
     *
     *     angle = 90 - gsk_conic_gradient_node_get_rotation()
     * @returns the angle for the gradient
     */
    get_angle(): number;
    /**
     * Retrieves the center pointer for the gradient.
     * @returns the center point for the gradient
     */
    get_center(): Graphene.Point;
    /**
     * Retrieves the color stops in the gradient.
     * @returns the color stops in the gradient
     */
    get_color_stops(): ColorStop[];
    /**
     * Retrieves the number of color stops in the gradient.
     * @returns the number of color stops
     */
    get_n_color_stops(): number;
    /**
     * Retrieves the rotation for the gradient in degrees.
     * @returns the rotation for the gradient
     */
    get_rotation(): number;
  }

  /**
   * A render node for a conic gradient.
   * @class
   */
  class ConicGradientNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ConicGradientNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.ConicGradientNode

    /**
     * Creates a `GskRenderNode` that draws a conic gradient.
     *
     * The conic gradient
     * starts around `center` in the direction of `rotation`. A rotation of 0 means
     * that the gradient points up. Color stops are then added clockwise.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param rotation the rotation of the gradient in degrees
     * @param color_stops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      rotation: number,
      color_stops: ColorStop[]
    );
    /**
     * Creates a `GskRenderNode` that draws a conic gradient.
     *
     * The conic gradient
     * starts around `center` in the direction of `rotation`. A rotation of 0 means
     * that the gradient points up. Color stops are then added clockwise.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param rotation the rotation of the gradient in degrees
     * @param color_stops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      rotation: number,
      color_stops: ColorStop[]
    ): ConicGradientNode;
  }

  interface ContainerNode {
    // Owm methods of Gsk-4.0.Gsk.ContainerNode

    /**
     * Gets one of the children of `container`.
     * @param idx the position of the child to get
     * @returns the @idx'th child of @container
     */
    get_child(idx: number): RenderNode;
    /**
     * Retrieves the number of direct children of `node`.
     * @returns the number of children of the `GskRenderNode`
     */
    get_n_children(): number;
  }

  /**
   * A render node that can contain other render nodes.
   * @class
   */
  class ContainerNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ContainerNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.ContainerNode

    /**
     * Creates a new `GskRenderNode` instance for holding the given `children`.
     *
     * The new node will acquire a reference to each of the children.
     * @constructor
     * @param children The children of the node
     * @returns the new `GskRenderNode`
     */
    constructor(children: RenderNode[]);
    /**
     * Creates a new `GskRenderNode` instance for holding the given `children`.
     *
     * The new node will acquire a reference to each of the children.
     * @constructor
     * @param children The children of the node
     * @returns the new `GskRenderNode`
     */
    static new(children: RenderNode[]): ContainerNode;
  }

  interface CrossFadeNode {
    // Owm methods of Gsk-4.0.Gsk.CrossFadeNode

    /**
     * Retrieves the child `GskRenderNode` at the end of the cross-fade.
     * @returns a `GskRenderNode`
     */
    get_end_child(): RenderNode;
    /**
     * Retrieves the progress value of the cross fade.
     * @returns the progress value, between 0 and 1
     */
    get_progress(): number;
    /**
     * Retrieves the child `GskRenderNode` at the beginning of the cross-fade.
     * @returns a `GskRenderNode`
     */
    get_start_child(): RenderNode;
  }

  /**
   * A render node cross fading between two child nodes.
   * @class
   */
  class CrossFadeNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.CrossFadeNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.CrossFadeNode

    /**
     * Creates a `GskRenderNode` that will do a cross-fade between `start` and `end`.
     * @constructor
     * @param start The start node to be drawn
     * @param end The node to be cross_fadeed onto the `start` node
     * @param progress How far the fade has progressed from start to end. The value will     be clamped to the range [0 ... 1]
     * @returns A new `GskRenderNode`
     */
    constructor(start: RenderNode, end: RenderNode, progress: number);
    /**
     * Creates a `GskRenderNode` that will do a cross-fade between `start` and `end`.
     * @constructor
     * @param start The start node to be drawn
     * @param end The node to be cross_fadeed onto the `start` node
     * @param progress How far the fade has progressed from start to end. The value will     be clamped to the range [0 ... 1]
     * @returns A new `GskRenderNode`
     */
    static new(
      start: RenderNode,
      end: RenderNode,
      progress: number
    ): CrossFadeNode;
  }

  interface DebugNode {
    // Owm methods of Gsk-4.0.Gsk.DebugNode

    /**
     * Gets the child node that is getting drawn by the given `node`.
     * @returns the child `GskRenderNode`
     */
    get_child(): RenderNode;
    /**
     * Gets the debug message that was set on this node
     * @returns The debug message
     */
    get_message(): string | null;
  }

  /**
   * A render node that emits a debugging message when drawing its
   * child node.
   * @class
   */
  class DebugNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.DebugNode

    static name: string;

    // Constructors of Gsk-4.0.Gsk.DebugNode

    /**
     * Creates a `GskRenderNode` that will add debug information about
     * the given `child`.
     *
     * Adding this node has no visual effect.
     * @constructor
     * @param child The child to add debug info for
     * @param message The debug message
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, message: string | null);
    /**
     * Creates a `GskRenderNode` that will add debug information about
     * the given `child`.
     *
     * Adding this node has no visual effect.
     * @constructor
     * @param child The child to add debug info for
     * @param message The debug message
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, message: string | null): DebugNode;
  }

  module GLRenderer {
    // Constructor properties interface

    type ConstructorProperties = Renderer.ConstructorProperties;
  }

  interface GLRenderer {
    // Class property signals of Gsk-4.0.Gsk.GLRenderer

    connect(
      sigName: "notify::realized",
      callback: ($obj: GLRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::realized",
      callback: ($obj: GLRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::realized", ...args: any[]): void;
    connect(
      sigName: "notify::surface",
      callback: ($obj: GLRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::surface",
      callback: ($obj: GLRenderer, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::surface", ...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;
  }

  class GLRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.GLRenderer

    static name: string;
    static $gtype: GObject.GType<GLRenderer>;

    // Constructors of Gsk-4.0.Gsk.GLRenderer

    constructor(config?: GLRenderer.ConstructorProperties);
    /**
     * Creates a new `GskRenderer` using the new OpenGL renderer.
     * @constructor
     * @returns a new GL renderer
     */
    constructor();
    /**
     * Creates a new `GskRenderer` using the new OpenGL renderer.
     * @constructor
     * @returns a new GL renderer
     */
    static new(): GLRenderer;
    _init(config?: GLRenderer.ConstructorProperties): void;
  }

  module GLShader {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gsk-4.0.Gsk.GLShader

      /**
       * Resource containing the source code for the shader.
       *
       * If the shader source is not coming from a resource, this
       * will be %NULL.
       */
      resource?: string | null;
      source?: GLib.Bytes | null;
    }
  }

  interface GLShader {
    // Own properties of Gsk-4.0.Gsk.GLShader

    /**
     * Resource containing the source code for the shader.
     *
     * If the shader source is not coming from a resource, this
     * will be %NULL.
     */
    readonly resource: string | null;
    readonly source: GLib.Bytes;

    // Owm methods of Gsk-4.0.Gsk.GLShader

    /**
     * Tries to compile the `shader` for the given `renderer`.
     *
     * If there is a problem, this function returns %FALSE and reports
     * an error. You should use this function before relying on the shader
     * for rendering and use a fallback with a simpler shader or without
     * shaders if it fails.
     *
     * Note that this will modify the rendering state (for example
     * change the current GL context) and requires the renderer to be
     * set up. This means that the widget has to be realized. Commonly you
     * want to call this from the realize signal of a widget, or during
     * widget snapshot.
     * @param renderer a `GskRenderer`
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    compile(renderer: Renderer): boolean;
    /**
     * Looks for a uniform by the name `name,` and returns the index
     * of the uniform, or -1 if it was not found.
     * @param name uniform name
     * @returns The index of the uniform, or -1
     */
    find_uniform_by_name(name: string | null): number;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of bool type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    get_arg_bool(args: GLib.Bytes, idx: number): boolean;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of float type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    get_arg_float(args: GLib.Bytes, idx: number): number;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of int type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    get_arg_int(args: GLib.Bytes, idx: number): number;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of uint type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    get_arg_uint(args: GLib.Bytes, idx: number): number;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of vec2 type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @param out_value location to store the uniform value in
     */
    get_arg_vec2(args: GLib.Bytes, idx: number, out_value: Graphene.Vec2): void;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of vec3 type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @param out_value location to store the uniform value in
     */
    get_arg_vec3(args: GLib.Bytes, idx: number, out_value: Graphene.Vec3): void;
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of vec4 type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @param out_value location to store set the uniform value in
     */
    get_arg_vec4(args: GLib.Bytes, idx: number, out_value: Graphene.Vec4): void;
    /**
     * Get the size of the data block used to specify arguments for this shader.
     * @returns The size of the data block
     */
    get_args_size(): number;
    /**
     * Returns the number of textures that the shader requires.
     *
     * This can be used to check that the a passed shader works
     * in your usecase. It is determined by looking at the highest
     * u_textureN value that the shader defines.
     * @returns The number of texture inputs required by @shader
     */
    get_n_textures(): number;
    /**
     * Get the number of declared uniforms for this shader.
     * @returns The number of declared uniforms
     */
    get_n_uniforms(): number;
    /**
     * Gets the resource path for the GLSL sourcecode being used
     * to render this shader.
     * @returns The resource path for the shader
     */
    get_resource(): string | null;
    /**
     * Gets the GLSL sourcecode being used to render this shader.
     * @returns The source code for the shader
     */
    get_source(): GLib.Bytes;
    /**
     * Get the name of the declared uniform for this shader at index `idx`.
     * @param idx index of the uniform
     * @returns The name of the declared uniform
     */
    get_uniform_name(idx: number): string | null;
    /**
     * Get the offset into the data block where data for this uniforms is stored.
     * @param idx index of the uniform
     * @returns The data offset
     */
    get_uniform_offset(idx: number): number;
    /**
     * Get the type of the declared uniform for this shader at index `idx`.
     * @param idx index of the uniform
     * @returns The type of the declared uniform
     */
    get_uniform_type(idx: number): GLUniformType;

    // Class property signals of Gsk-4.0.Gsk.GLShader

    connect(
      sigName: "notify::resource",
      callback: ($obj: GLShader, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::resource",
      callback: ($obj: GLShader, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::resource", ...args: any[]): void;
    connect(
      sigName: "notify::source",
      callback: ($obj: GLShader, pspec: GObject.ParamSpec) => void
    ): number;
    connect_after(
      sigName: "notify::source",
      callback: ($obj: GLShader, pspec: GObject.ParamSpec) => void
    ): number;
    emit(sigName: "notify::source", ...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 `GskGLShader` is a snippet of GLSL that is meant to run in the
   * fragment shader of the rendering pipeline.
   *
   * A fragment shader gets the coordinates being rendered as input and
   * produces the pixel values for that particular pixel. Additionally,
   * the shader can declare a set of other input arguments, called
   * uniforms (as they are uniform over all the calls to your shader in
   * each instance of use). A shader can also receive up to 4
   * textures that it can use as input when producing the pixel data.
   *
   * `GskGLShader` is usually used with gtk_snapshot_push_gl_shader()
   * to produce a [class`Gsk`.GLShaderNode] in the rendering hierarchy,
   * and then its input textures are constructed by rendering the child
   * nodes to textures before rendering the shader node itself. (You can
   * pass texture nodes as children if you want to directly use a texture
   * as input).
   *
   * The actual shader code is GLSL code that gets combined with
   * some other code into the fragment shader. Since the exact
   * capabilities of the GPU driver differs between different OpenGL
   * drivers and hardware, GTK adds some defines that you can use
   * to ensure your GLSL code runs on as many drivers as it can.
   *
   * If the OpenGL driver is GLES, then the shader language version
   * is set to 100, and GSK_GLES will be defined in the shader.
   *
   * Otherwise, if the OpenGL driver does not support the 3.2 core profile,
   * then the shader will run with language version 110 for GL2 and 130 for GL3,
   * and GSK_LEGACY will be defined in the shader.
   *
   * If the OpenGL driver supports the 3.2 code profile, it will be used,
   * the shader language version is set to 150, and GSK_GL3 will be defined
   * in the shader.
   *
   * The main function the shader must implement is:
   *
   * ```glsl
   *  void mainImage(out vec4 fragColor,
   *                 in vec2 fragCoord,
   *                 in vec2 resolution,
   *                 in vec2 uv)
   * ```
   *
   * Where the input `fragCoord` is the coordinate of the pixel we're
   * currently rendering, relative to the boundary rectangle that was
   * specified in the `GskGLShaderNode`, and `resolution` is the width and
   * height of that rectangle. This is in the typical GTK coordinate
   * system with the origin in the top left. `uv` contains the u and v
   * coordinates that can be used to index a texture at the
   * corresponding point. These coordinates are in the [0..1]x[0..1]
   * region, with 0, 0 being in the lower left corder (which is typical
   * for OpenGL).
   *
   * The output `fragColor` should be a RGBA color (with
   * premultiplied alpha) that will be used as the output for the
   * specified pixel location. Note that this output will be
   * automatically clipped to the clip region of the glshader node.
   *
   * In addition to the function arguments the shader can define
   * up to 4 uniforms for textures which must be called u_textureN
   * (i.e. u_texture1 to u_texture4) as well as any custom uniforms
   * you want of types int, uint, bool, float, vec2, vec3 or vec4.
   *
   * All textures sources contain premultiplied alpha colors, but if some
   * there are outer sources of colors there is a gsk_premultiply() helper
   * to compute premultiplication when needed.
   *
   * Note that GTK parses the uniform declarations, so each uniform has to
   * be on a line by itself with no other code, like so:
   *
   * ```glsl
   * uniform float u_time;
   * uniform vec3 u_color;
   * uniform sampler2D u_texture1;
   * uniform sampler2D u_texture2;
   * ```
   *
   * GTK uses the "gsk" namespace in the symbols it uses in the
   * shader, so your code should not use any symbols with the prefix gsk
   * or GSK. There are some helper functions declared that you can use:
   *
   * ```glsl
   * vec4 GskTexture(sampler2D sampler, vec2 texCoords);
   * ```
   *
   * This samples a texture (e.g. u_texture1) at the specified
   * coordinates, and containes some helper ifdefs to ensure that
   * it works on all OpenGL versions.
   *
   * You can compile the shader yourself using [method`Gsk`.GLShader.compile],
   * otherwise the GSK renderer will do it when it handling the glshader
   * node. If errors occurs, the returned `error` will include the glsl
   * sources, so you can see what GSK was passing to the compiler. You
   * can also set GSK_DEBUG=shaders in the environment to see the sources
   * and other relevant information about all shaders that GSK is handling.
   *
   * # An example shader
   *
   * ```glsl
   * uniform float position;
   * uniform sampler2D u_texture1;
   * uniform sampler2D u_texture2;
   *
   * void mainImage(out vec4 fragColor,
   *                in vec2 fragCoord,
   *                in vec2 resolution,
   *                in vec2 uv) {
   *   vec4 source1 = GskTexture(u_texture1, uv);
   *   vec4 source2 = GskTexture(u_texture2, uv);
   *
   *   fragColor = position * source1 + (1.0 - position) * source2;
   * }
   * ```
   * @class
   */
  class GLShader extends GObject.Object {
    // Own properties of Gsk-4.0.Gsk.GLShader

    static name: string;
    static $gtype: GObject.GType<GLShader>;

    // Constructors of Gsk-4.0.Gsk.GLShader

    constructor(config?: GLShader.ConstructorProperties);
    /**
     * Creates a `GskGLShader` that will render pixels using the specified code.
     * @constructor
     * @param sourcecode GLSL sourcecode for the shader, as a `GBytes`
     * @returns A new `GskGLShader`
     */
    static new_from_bytes(sourcecode: GLib.Bytes): GLShader;
    /**
     * Creates a `GskGLShader` that will render pixels using the specified code.
     * @constructor
     * @param resource_path path to a resource that contains the GLSL sourcecode for     the shader
     * @returns A new `GskGLShader`
     */
    static new_from_resource(resource_path: string | null): GLShader;
    _init(config?: GLShader.ConstructorProperties): void;
  }

  interface GLShaderNode {
    // Owm methods of Gsk-4.0.Gsk.GLShaderNode

    /**
     * Gets args for the node.
     * @returns A `GBytes` with the uniform arguments
     */
    get_args(): GLib.Bytes;
    /**
     * Gets one of the children.
     * @param idx the position of the child to get
     * @returns the @idx'th child of @node
     */
    get_child(idx: number): RenderNode;
    /**
     * Returns the number of children
     * @returns The number of children
     */
    get_n_children(): number;
    /**
     * Gets shader code for the node.
     * @returns the `GskGLShader` shader
     */
    get_shader(): GLShader;
  }

  /**
   * A render node using a GL shader when drawing its children nodes.
   * @class
   */
  class GLShaderNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.GLShaderNode

    static name: string;

    // Constructors o