// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use cairo_sys as cairo;
use gdk4_sys as gdk;
use glib_sys as glib;
use gobject_sys as gobject;
use graphene_sys as graphene;
use pango_sys as pango;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type GskBlendMode = c_int;
pub const GSK_BLEND_MODE_DEFAULT: GskBlendMode = 0;
pub const GSK_BLEND_MODE_MULTIPLY: GskBlendMode = 1;
pub const GSK_BLEND_MODE_SCREEN: GskBlendMode = 2;
pub const GSK_BLEND_MODE_OVERLAY: GskBlendMode = 3;
pub const GSK_BLEND_MODE_DARKEN: GskBlendMode = 4;
pub const GSK_BLEND_MODE_LIGHTEN: GskBlendMode = 5;
pub const GSK_BLEND_MODE_COLOR_DODGE: GskBlendMode = 6;
pub const GSK_BLEND_MODE_COLOR_BURN: GskBlendMode = 7;
pub const GSK_BLEND_MODE_HARD_LIGHT: GskBlendMode = 8;
pub const GSK_BLEND_MODE_SOFT_LIGHT: GskBlendMode = 9;
pub const GSK_BLEND_MODE_DIFFERENCE: GskBlendMode = 10;
pub const GSK_BLEND_MODE_EXCLUSION: GskBlendMode = 11;
pub const GSK_BLEND_MODE_COLOR: GskBlendMode = 12;
pub const GSK_BLEND_MODE_HUE: GskBlendMode = 13;
pub const GSK_BLEND_MODE_SATURATION: GskBlendMode = 14;
pub const GSK_BLEND_MODE_LUMINOSITY: GskBlendMode = 15;

pub type GskCorner = c_int;
pub const GSK_CORNER_TOP_LEFT: GskCorner = 0;
pub const GSK_CORNER_TOP_RIGHT: GskCorner = 1;
pub const GSK_CORNER_BOTTOM_RIGHT: GskCorner = 2;
pub const GSK_CORNER_BOTTOM_LEFT: GskCorner = 3;

pub type GskFillRule = c_int;
pub const GSK_FILL_RULE_WINDING: GskFillRule = 0;
pub const GSK_FILL_RULE_EVEN_ODD: GskFillRule = 1;

pub type GskGLUniformType = c_int;
pub const GSK_GL_UNIFORM_TYPE_NONE: GskGLUniformType = 0;
pub const GSK_GL_UNIFORM_TYPE_FLOAT: GskGLUniformType = 1;
pub const GSK_GL_UNIFORM_TYPE_INT: GskGLUniformType = 2;
pub const GSK_GL_UNIFORM_TYPE_UINT: GskGLUniformType = 3;
pub const GSK_GL_UNIFORM_TYPE_BOOL: GskGLUniformType = 4;
pub const GSK_GL_UNIFORM_TYPE_VEC2: GskGLUniformType = 5;
pub const GSK_GL_UNIFORM_TYPE_VEC3: GskGLUniformType = 6;
pub const GSK_GL_UNIFORM_TYPE_VEC4: GskGLUniformType = 7;

pub type GskLineCap = c_int;
pub const GSK_LINE_CAP_BUTT: GskLineCap = 0;
pub const GSK_LINE_CAP_ROUND: GskLineCap = 1;
pub const GSK_LINE_CAP_SQUARE: GskLineCap = 2;

pub type GskLineJoin = c_int;
pub const GSK_LINE_JOIN_MITER: GskLineJoin = 0;
pub const GSK_LINE_JOIN_ROUND: GskLineJoin = 1;
pub const GSK_LINE_JOIN_BEVEL: GskLineJoin = 2;

pub type GskMaskMode = c_int;
pub const GSK_MASK_MODE_ALPHA: GskMaskMode = 0;
pub const GSK_MASK_MODE_INVERTED_ALPHA: GskMaskMode = 1;
pub const GSK_MASK_MODE_LUMINANCE: GskMaskMode = 2;
pub const GSK_MASK_MODE_INVERTED_LUMINANCE: GskMaskMode = 3;

pub type GskPathDirection = c_int;
pub const GSK_PATH_FROM_START: GskPathDirection = 0;
pub const GSK_PATH_TO_START: GskPathDirection = 1;
pub const GSK_PATH_TO_END: GskPathDirection = 2;
pub const GSK_PATH_FROM_END: GskPathDirection = 3;

pub type GskPathIntersection = c_int;
pub const GSK_PATH_INTERSECTION_NONE: GskPathIntersection = 0;
pub const GSK_PATH_INTERSECTION_NORMAL: GskPathIntersection = 1;
pub const GSK_PATH_INTERSECTION_START: GskPathIntersection = 2;
pub const GSK_PATH_INTERSECTION_END: GskPathIntersection = 3;

pub type GskPathOperation = c_int;
pub const GSK_PATH_MOVE: GskPathOperation = 0;
pub const GSK_PATH_CLOSE: GskPathOperation = 1;
pub const GSK_PATH_LINE: GskPathOperation = 2;
pub const GSK_PATH_QUAD: GskPathOperation = 3;
pub const GSK_PATH_CUBIC: GskPathOperation = 4;
pub const GSK_PATH_CONIC: GskPathOperation = 5;

pub type GskRenderNodeType = c_int;
pub const GSK_NOT_A_RENDER_NODE: GskRenderNodeType = 0;
pub const GSK_CONTAINER_NODE: GskRenderNodeType = 1;
pub const GSK_CAIRO_NODE: GskRenderNodeType = 2;
pub const GSK_COLOR_NODE: GskRenderNodeType = 3;
pub const GSK_LINEAR_GRADIENT_NODE: GskRenderNodeType = 4;
pub const GSK_REPEATING_LINEAR_GRADIENT_NODE: GskRenderNodeType = 5;
pub const GSK_RADIAL_GRADIENT_NODE: GskRenderNodeType = 6;
pub const GSK_REPEATING_RADIAL_GRADIENT_NODE: GskRenderNodeType = 7;
pub const GSK_CONIC_GRADIENT_NODE: GskRenderNodeType = 8;
pub const GSK_BORDER_NODE: GskRenderNodeType = 9;
pub const GSK_TEXTURE_NODE: GskRenderNodeType = 10;
pub const GSK_INSET_SHADOW_NODE: GskRenderNodeType = 11;
pub const GSK_OUTSET_SHADOW_NODE: GskRenderNodeType = 12;
pub const GSK_TRANSFORM_NODE: GskRenderNodeType = 13;
pub const GSK_OPACITY_NODE: GskRenderNodeType = 14;
pub const GSK_COLOR_MATRIX_NODE: GskRenderNodeType = 15;
pub const GSK_REPEAT_NODE: GskRenderNodeType = 16;
pub const GSK_CLIP_NODE: GskRenderNodeType = 17;
pub const GSK_ROUNDED_CLIP_NODE: GskRenderNodeType = 18;
pub const GSK_SHADOW_NODE: GskRenderNodeType = 19;
pub const GSK_BLEND_NODE: GskRenderNodeType = 20;
pub const GSK_CROSS_FADE_NODE: GskRenderNodeType = 21;
pub const GSK_TEXT_NODE: GskRenderNodeType = 22;
pub const GSK_BLUR_NODE: GskRenderNodeType = 23;
pub const GSK_DEBUG_NODE: GskRenderNodeType = 24;
pub const GSK_GL_SHADER_NODE: GskRenderNodeType = 25;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub const GSK_TEXTURE_SCALE_NODE: GskRenderNodeType = 26;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub const GSK_MASK_NODE: GskRenderNodeType = 27;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub const GSK_FILL_NODE: GskRenderNodeType = 28;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub const GSK_STROKE_NODE: GskRenderNodeType = 29;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub const GSK_SUBSURFACE_NODE: GskRenderNodeType = 30;
#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
pub const GSK_COMPONENT_TRANSFER_NODE: GskRenderNodeType = 31;

pub type GskScalingFilter = c_int;
pub const GSK_SCALING_FILTER_LINEAR: GskScalingFilter = 0;
pub const GSK_SCALING_FILTER_NEAREST: GskScalingFilter = 1;
pub const GSK_SCALING_FILTER_TRILINEAR: GskScalingFilter = 2;

pub type GskSerializationError = c_int;
pub const GSK_SERIALIZATION_UNSUPPORTED_FORMAT: GskSerializationError = 0;
pub const GSK_SERIALIZATION_UNSUPPORTED_VERSION: GskSerializationError = 1;
pub const GSK_SERIALIZATION_INVALID_DATA: GskSerializationError = 2;

pub type GskTransformCategory = c_int;
pub const GSK_TRANSFORM_CATEGORY_UNKNOWN: GskTransformCategory = 0;
pub const GSK_TRANSFORM_CATEGORY_ANY: GskTransformCategory = 1;
pub const GSK_TRANSFORM_CATEGORY_3D: GskTransformCategory = 2;
pub const GSK_TRANSFORM_CATEGORY_2D: GskTransformCategory = 3;
pub const GSK_TRANSFORM_CATEGORY_2D_AFFINE: GskTransformCategory = 4;
pub const GSK_TRANSFORM_CATEGORY_2D_TRANSLATE: GskTransformCategory = 5;
pub const GSK_TRANSFORM_CATEGORY_IDENTITY: GskTransformCategory = 6;

// Flags
pub type GskPathForeachFlags = c_uint;
pub const GSK_PATH_FOREACH_ALLOW_ONLY_LINES: GskPathForeachFlags = 0;
pub const GSK_PATH_FOREACH_ALLOW_QUAD: GskPathForeachFlags = 1;
pub const GSK_PATH_FOREACH_ALLOW_CUBIC: GskPathForeachFlags = 2;
pub const GSK_PATH_FOREACH_ALLOW_CONIC: GskPathForeachFlags = 4;

// Unions
#[derive(Copy, Clone)]
#[repr(C)]
pub union GskPathPoint_u1 {
    pub s1: GskPathPoint__s1,
    pub padding: [gpointer; 8],
    pub alignment: graphene::graphene_vec4_t,
}

impl ::std::fmt::Debug for GskPathPoint_u1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskPathPoint_u1 @ {self:p}"))
            .field("s1", unsafe { &self.s1 })
            .field("padding", unsafe { &self.padding })
            .field("alignment", unsafe { &self.alignment })
            .finish()
    }
}

// Callbacks
pub type GskParseErrorFunc = Option<
    unsafe extern "C" fn(
        *const GskParseLocation,
        *const GskParseLocation,
        *const glib::GError,
        gpointer,
    ),
>;
pub type GskPathForeachFunc = Option<
    unsafe extern "C" fn(
        GskPathOperation,
        *const graphene::graphene_point_t,
        size_t,
        c_float,
        gpointer,
    ) -> gboolean,
>;
pub type GskPathIntersectionFunc = Option<
    unsafe extern "C" fn(
        *mut GskPath,
        *const GskPathPoint,
        *mut GskPath,
        *const GskPathPoint,
        GskPathIntersection,
        gpointer,
    ) -> gboolean,
>;

// Records
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
#[repr(C)]
#[allow(dead_code)]
pub struct _GskBroadwayRendererClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
pub type GskBroadwayRendererClass = _GskBroadwayRendererClass;

#[repr(C)]
#[allow(dead_code)]
pub struct _GskCairoRendererClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type GskCairoRendererClass = _GskCairoRendererClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskColorStop {
    pub offset: c_float,
    pub color: gdk::GdkRGBA,
}

impl ::std::fmt::Debug for GskColorStop {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskColorStop @ {self:p}"))
            .field("offset", &self.offset)
            .field("color", &self.color)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskComponentTransfer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskComponentTransfer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskComponentTransfer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _GskGLRendererClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type GskGLRendererClass = _GskGLRendererClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskGLShaderClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for GskGLShaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLShaderClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskParseLocation {
    pub bytes: size_t,
    pub chars: size_t,
    pub lines: size_t,
    pub line_bytes: size_t,
    pub line_chars: size_t,
}

impl ::std::fmt::Debug for GskParseLocation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskParseLocation @ {self:p}"))
            .field("bytes", &self.bytes)
            .field("chars", &self.chars)
            .field("lines", &self.lines)
            .field("line_bytes", &self.line_bytes)
            .field("line_chars", &self.line_chars)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskPath {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskPath {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskPath @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskPathBuilder {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskPathBuilder {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskPathBuilder @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskPathMeasure {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskPathMeasure {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskPathMeasure @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskPathPoint {
    pub u1: GskPathPoint_u1,
}

impl ::std::fmt::Debug for GskPathPoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskPathPoint @ {self:p}"))
            .field("u1", &self.u1)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskPathPoint__s1 {
    pub contour: size_t,
    pub idx: size_t,
    pub t: c_float,
}

impl ::std::fmt::Debug for GskPathPoint__s1 {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskPathPoint__s1 @ {self:p}"))
            .field("contour", &self.contour)
            .field("idx", &self.idx)
            .field("t", &self.t)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct _GskRendererClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type GskRendererClass = _GskRendererClass;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskRoundedRect {
    pub bounds: graphene::graphene_rect_t,
    pub corner: [graphene::graphene_size_t; 4],
}

impl ::std::fmt::Debug for GskRoundedRect {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRoundedRect @ {self:p}"))
            .field("bounds", &self.bounds)
            .field("corner", &self.corner)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskShaderArgsBuilder {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskShaderArgsBuilder {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskShaderArgsBuilder @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskShadow {
    pub color: gdk::GdkRGBA,
    pub dx: c_float,
    pub dy: c_float,
    pub radius: c_float,
}

impl ::std::fmt::Debug for GskShadow {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskShadow @ {self:p}"))
            .field("color", &self.color)
            .field("dx", &self.dx)
            .field("dy", &self.dy)
            .field("radius", &self.radius)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskStroke {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskStroke {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskStroke @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskTransform {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskTransform {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTransform @ {self:p}")).finish()
    }
}

#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
#[repr(C)]
#[allow(dead_code)]
pub struct _GskVulkanRendererClass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
pub type GskVulkanRendererClass = _GskVulkanRendererClass;

// Classes
#[repr(C)]
#[allow(dead_code)]
pub struct GskBlendNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskBlendNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBlendNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskBlurNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskBlurNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBlurNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskBorderNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskBorderNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBorderNode @ {self:p}"))
            .finish()
    }
}

#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
#[repr(C)]
#[allow(dead_code)]
pub struct GskBroadwayRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
impl ::std::fmt::Debug for GskBroadwayRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBroadwayRenderer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskCairoNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskCairoNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskCairoNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskCairoRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskCairoRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskCairoRenderer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskClipNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskClipNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskClipNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskColorMatrixNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskColorMatrixNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskColorMatrixNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskColorNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskColorNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskColorNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskComponentTransferNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskComponentTransferNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskComponentTransferNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskConicGradientNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskConicGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskConicGradientNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskContainerNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskContainerNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskContainerNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskCrossFadeNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskCrossFadeNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskCrossFadeNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskDebugNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskDebugNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskDebugNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskFillNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskFillNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskFillNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskGLRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskGLRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLRenderer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskGLShader {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskGLShader {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLShader @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskGLShaderNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskGLShaderNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLShaderNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskInsetShadowNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskInsetShadowNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskInsetShadowNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskLinearGradientNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskLinearGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskLinearGradientNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskMaskNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskMaskNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskMaskNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskNglRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskNglRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskNglRenderer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskOpacityNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskOpacityNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskOpacityNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskOutsetShadowNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskOutsetShadowNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskOutsetShadowNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRadialGradientNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRadialGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRadialGradientNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRenderNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRenderNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRenderNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRenderer @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRepeatNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRepeatNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRepeatNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRepeatingLinearGradientNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRepeatingLinearGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRepeatingLinearGradientNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRepeatingRadialGradientNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRepeatingRadialGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRepeatingRadialGradientNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskRoundedClipNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskRoundedClipNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRoundedClipNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskShadowNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskShadowNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskShadowNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskStrokeNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskStrokeNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskStrokeNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskSubsurfaceNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskSubsurfaceNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskSubsurfaceNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskTextNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskTextNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTextNode @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskTextureNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskTextureNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTextureNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskTextureScaleNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskTextureScaleNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTextureScaleNode @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GskTransformNode {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GskTransformNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTransformNode @ {self:p}"))
            .finish()
    }
}

#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
#[repr(C)]
#[allow(dead_code)]
pub struct GskVulkanRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
impl ::std::fmt::Debug for GskVulkanRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskVulkanRenderer @ {self:p}"))
            .finish()
    }
}

extern "C" {

    //=========================================================================
    // GskBlendMode
    //=========================================================================
    pub fn gsk_blend_mode_get_type() -> GType;

    //=========================================================================
    // GskCorner
    //=========================================================================
    pub fn gsk_corner_get_type() -> GType;

    //=========================================================================
    // GskFillRule
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_fill_rule_get_type() -> GType;

    //=========================================================================
    // GskGLUniformType
    //=========================================================================
    pub fn gsk_gl_uniform_type_get_type() -> GType;

    //=========================================================================
    // GskLineCap
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_line_cap_get_type() -> GType;

    //=========================================================================
    // GskLineJoin
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_line_join_get_type() -> GType;

    //=========================================================================
    // GskMaskMode
    //=========================================================================
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_mask_mode_get_type() -> GType;

    //=========================================================================
    // GskPathDirection
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_direction_get_type() -> GType;

    //=========================================================================
    // GskPathIntersection
    //=========================================================================
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_path_intersection_get_type() -> GType;

    //=========================================================================
    // GskPathOperation
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_operation_get_type() -> GType;

    //=========================================================================
    // GskRenderNodeType
    //=========================================================================
    pub fn gsk_render_node_type_get_type() -> GType;

    //=========================================================================
    // GskScalingFilter
    //=========================================================================
    pub fn gsk_scaling_filter_get_type() -> GType;

    //=========================================================================
    // GskSerializationError
    //=========================================================================
    pub fn gsk_serialization_error_get_type() -> GType;
    pub fn gsk_serialization_error_quark() -> glib::GQuark;

    //=========================================================================
    // GskTransformCategory
    //=========================================================================
    pub fn gsk_transform_category_get_type() -> GType;

    //=========================================================================
    // GskPathForeachFlags
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_foreach_flags_get_type() -> GType;

    //=========================================================================
    // GskComponentTransfer
    //=========================================================================
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_get_type() -> GType;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_new_discrete(
        n: c_uint,
        values: *mut c_float,
    ) -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_new_gamma(
        amp: c_float,
        exp: c_float,
        ofs: c_float,
    ) -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_new_identity() -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_new_levels(n: c_float) -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_new_linear(m: c_float, b: c_float) -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_new_table(
        n: c_uint,
        values: *mut c_float,
    ) -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_copy(
        other: *const GskComponentTransfer,
    ) -> *mut GskComponentTransfer;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_free(self_: *mut GskComponentTransfer);
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_equal(self_: gconstpointer, other: gconstpointer) -> gboolean;

    //=========================================================================
    // GskPath
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_foreach(
        self_: *mut GskPath,
        flags: GskPathForeachFlags,
        func: GskPathForeachFunc,
        user_data: gpointer,
    ) -> gboolean;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_path_foreach_intersection(
        path1: *mut GskPath,
        path2: *mut GskPath,
        func: GskPathIntersectionFunc,
        user_data: gpointer,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_get_bounds(
        self_: *mut GskPath,
        bounds: *mut graphene::graphene_rect_t,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_get_closest_point(
        self_: *mut GskPath,
        point: *const graphene::graphene_point_t,
        threshold: c_float,
        result: *mut GskPathPoint,
        distance: *mut c_float,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_get_end_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_get_start_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_get_stroke_bounds(
        self_: *mut GskPath,
        stroke: *const GskStroke,
        bounds: *mut graphene::graphene_rect_t,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_in_fill(
        self_: *mut GskPath,
        point: *const graphene::graphene_point_t,
        fill_rule: GskFillRule,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_is_closed(self_: *mut GskPath) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_is_empty(self_: *mut GskPath) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_print(self_: *mut GskPath, string: *mut glib::GString);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_ref(self_: *mut GskPath) -> *mut GskPath;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_to_cairo(self_: *mut GskPath, cr: *mut cairo::cairo_t);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_to_string(self_: *mut GskPath) -> *mut c_char;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_unref(self_: *mut GskPath);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_parse(string: *const c_char) -> *mut GskPath;

    //=========================================================================
    // GskPathBuilder
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_new() -> *mut GskPathBuilder;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_cairo_path(
        self_: *mut GskPathBuilder,
        path: *const cairo::cairo_path_t,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_circle(
        self_: *mut GskPathBuilder,
        center: *const graphene::graphene_point_t,
        radius: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_layout(self_: *mut GskPathBuilder, layout: *mut pango::PangoLayout);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_path(self_: *mut GskPathBuilder, path: *mut GskPath);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_rect(
        self_: *mut GskPathBuilder,
        rect: *const graphene::graphene_rect_t,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_reverse_path(self_: *mut GskPathBuilder, path: *mut GskPath);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_rounded_rect(
        self_: *mut GskPathBuilder,
        rect: *const GskRoundedRect,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_add_segment(
        self_: *mut GskPathBuilder,
        path: *mut GskPath,
        start: *const GskPathPoint,
        end: *const GskPathPoint,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_arc_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_close(self_: *mut GskPathBuilder);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_conic_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
        weight: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_cubic_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
        x3: c_float,
        y3: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_free_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_get_current_point(
        self_: *mut GskPathBuilder,
    ) -> *const graphene::graphene_point_t;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_html_arc_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
        radius: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_quad_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_ref(self_: *mut GskPathBuilder) -> *mut GskPathBuilder;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_arc_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_conic_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
        weight: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_cubic_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
        x3: c_float,
        y3: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_html_arc_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
        radius: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_quad_to(
        self_: *mut GskPathBuilder,
        x1: c_float,
        y1: c_float,
        x2: c_float,
        y2: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_rel_svg_arc_to(
        self_: *mut GskPathBuilder,
        rx: c_float,
        ry: c_float,
        x_axis_rotation: c_float,
        large_arc: gboolean,
        positive_sweep: gboolean,
        x: c_float,
        y: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_svg_arc_to(
        self_: *mut GskPathBuilder,
        rx: c_float,
        ry: c_float,
        x_axis_rotation: c_float,
        large_arc: gboolean,
        positive_sweep: gboolean,
        x: c_float,
        y: c_float,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_builder_unref(self_: *mut GskPathBuilder);

    //=========================================================================
    // GskPathMeasure
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_new(path: *mut GskPath) -> *mut GskPathMeasure;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_new_with_tolerance(
        path: *mut GskPath,
        tolerance: c_float,
    ) -> *mut GskPathMeasure;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_get_length(self_: *mut GskPathMeasure) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_get_path(self_: *mut GskPathMeasure) -> *mut GskPath;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_get_point(
        self_: *mut GskPathMeasure,
        distance: c_float,
        result: *mut GskPathPoint,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_get_tolerance(self_: *mut GskPathMeasure) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_ref(self_: *mut GskPathMeasure) -> *mut GskPathMeasure;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_measure_unref(self_: *mut GskPathMeasure);

    //=========================================================================
    // GskPathPoint
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_compare(
        point1: *const GskPathPoint,
        point2: *const GskPathPoint,
    ) -> c_int;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_copy(point: *mut GskPathPoint) -> *mut GskPathPoint;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_equal(
        point1: *const GskPathPoint,
        point2: *const GskPathPoint,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_free(point: *mut GskPathPoint);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_get_curvature(
        point: *const GskPathPoint,
        path: *mut GskPath,
        direction: GskPathDirection,
        center: *mut graphene::graphene_point_t,
    ) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_get_distance(
        point: *const GskPathPoint,
        measure: *mut GskPathMeasure,
    ) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_get_position(
        point: *const GskPathPoint,
        path: *mut GskPath,
        position: *mut graphene::graphene_point_t,
    );
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_get_rotation(
        point: *const GskPathPoint,
        path: *mut GskPath,
        direction: GskPathDirection,
    ) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_path_point_get_tangent(
        point: *const GskPathPoint,
        path: *mut GskPath,
        direction: GskPathDirection,
        tangent: *mut graphene::graphene_vec2_t,
    );

    //=========================================================================
    // GskRoundedRect
    //=========================================================================
    pub fn gsk_rounded_rect_contains_point(
        self_: *const GskRoundedRect,
        point: *const graphene::graphene_point_t,
    ) -> gboolean;
    pub fn gsk_rounded_rect_contains_rect(
        self_: *const GskRoundedRect,
        rect: *const graphene::graphene_rect_t,
    ) -> gboolean;
    pub fn gsk_rounded_rect_init(
        self_: *mut GskRoundedRect,
        bounds: *const graphene::graphene_rect_t,
        top_left: *const graphene::graphene_size_t,
        top_right: *const graphene::graphene_size_t,
        bottom_right: *const graphene::graphene_size_t,
        bottom_left: *const graphene::graphene_size_t,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_init_copy(
        self_: *mut GskRoundedRect,
        src: *const GskRoundedRect,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_init_from_rect(
        self_: *mut GskRoundedRect,
        bounds: *const graphene::graphene_rect_t,
        radius: c_float,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_intersects_rect(
        self_: *const GskRoundedRect,
        rect: *const graphene::graphene_rect_t,
    ) -> gboolean;
    pub fn gsk_rounded_rect_is_rectilinear(self_: *const GskRoundedRect) -> gboolean;
    pub fn gsk_rounded_rect_normalize(self_: *mut GskRoundedRect) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_offset(
        self_: *mut GskRoundedRect,
        dx: c_float,
        dy: c_float,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_shrink(
        self_: *mut GskRoundedRect,
        top: c_float,
        right: c_float,
        bottom: c_float,
        left: c_float,
    ) -> *mut GskRoundedRect;

    //=========================================================================
    // GskShaderArgsBuilder
    //=========================================================================
    pub fn gsk_shader_args_builder_get_type() -> GType;
    pub fn gsk_shader_args_builder_new(
        shader: *mut GskGLShader,
        initial_values: *mut glib::GBytes,
    ) -> *mut GskShaderArgsBuilder;
    pub fn gsk_shader_args_builder_free_to_args(
        builder: *mut GskShaderArgsBuilder,
    ) -> *mut glib::GBytes;
    pub fn gsk_shader_args_builder_ref(
        builder: *mut GskShaderArgsBuilder,
    ) -> *mut GskShaderArgsBuilder;
    pub fn gsk_shader_args_builder_set_bool(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: gboolean,
    );
    pub fn gsk_shader_args_builder_set_float(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: c_float,
    );
    pub fn gsk_shader_args_builder_set_int(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: i32,
    );
    pub fn gsk_shader_args_builder_set_uint(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: u32,
    );
    pub fn gsk_shader_args_builder_set_vec2(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: *const graphene::graphene_vec2_t,
    );
    pub fn gsk_shader_args_builder_set_vec3(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: *const graphene::graphene_vec3_t,
    );
    pub fn gsk_shader_args_builder_set_vec4(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: *const graphene::graphene_vec4_t,
    );
    pub fn gsk_shader_args_builder_to_args(builder: *mut GskShaderArgsBuilder)
        -> *mut glib::GBytes;
    pub fn gsk_shader_args_builder_unref(builder: *mut GskShaderArgsBuilder);

    //=========================================================================
    // GskStroke
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_new(line_width: c_float) -> *mut GskStroke;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_copy(other: *const GskStroke) -> *mut GskStroke;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_free(self_: *mut GskStroke);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_dash(self_: *const GskStroke, n_dash: *mut size_t) -> *const c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_dash_offset(self_: *const GskStroke) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_line_cap(self_: *const GskStroke) -> GskLineCap;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_line_join(self_: *const GskStroke) -> GskLineJoin;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_line_width(self_: *const GskStroke) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_get_miter_limit(self_: *const GskStroke) -> c_float;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_set_dash(self_: *mut GskStroke, dash: *const c_float, n_dash: size_t);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_set_dash_offset(self_: *mut GskStroke, offset: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_set_line_cap(self_: *mut GskStroke, line_cap: GskLineCap);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_set_line_join(self_: *mut GskStroke, line_join: GskLineJoin);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_set_line_width(self_: *mut GskStroke, line_width: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_set_miter_limit(self_: *mut GskStroke, limit: c_float);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_to_cairo(self_: *const GskStroke, cr: *mut cairo::cairo_t);
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_equal(stroke1: gconstpointer, stroke2: gconstpointer) -> gboolean;

    //=========================================================================
    // GskTransform
    //=========================================================================
    pub fn gsk_transform_get_type() -> GType;
    pub fn gsk_transform_new() -> *mut GskTransform;
    pub fn gsk_transform_equal(first: *mut GskTransform, second: *mut GskTransform) -> gboolean;
    pub fn gsk_transform_get_category(self_: *mut GskTransform) -> GskTransformCategory;
    pub fn gsk_transform_invert(self_: *mut GskTransform) -> *mut GskTransform;
    pub fn gsk_transform_matrix(
        next: *mut GskTransform,
        matrix: *const graphene::graphene_matrix_t,
    ) -> *mut GskTransform;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_transform_matrix_2d(
        next: *mut GskTransform,
        xx: c_float,
        yx: c_float,
        xy: c_float,
        yy: c_float,
        dx: c_float,
        dy: c_float,
    ) -> *mut GskTransform;
    pub fn gsk_transform_perspective(next: *mut GskTransform, depth: c_float) -> *mut GskTransform;
    pub fn gsk_transform_print(self_: *mut GskTransform, string: *mut glib::GString);
    pub fn gsk_transform_ref(self_: *mut GskTransform) -> *mut GskTransform;
    pub fn gsk_transform_rotate(next: *mut GskTransform, angle: c_float) -> *mut GskTransform;
    pub fn gsk_transform_rotate_3d(
        next: *mut GskTransform,
        angle: c_float,
        axis: *const graphene::graphene_vec3_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_scale(
        next: *mut GskTransform,
        factor_x: c_float,
        factor_y: c_float,
    ) -> *mut GskTransform;
    pub fn gsk_transform_scale_3d(
        next: *mut GskTransform,
        factor_x: c_float,
        factor_y: c_float,
        factor_z: c_float,
    ) -> *mut GskTransform;
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    pub fn gsk_transform_skew(
        next: *mut GskTransform,
        skew_x: c_float,
        skew_y: c_float,
    ) -> *mut GskTransform;
    pub fn gsk_transform_to_2d(
        self_: *mut GskTransform,
        out_xx: *mut c_float,
        out_yx: *mut c_float,
        out_xy: *mut c_float,
        out_yy: *mut c_float,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    pub fn gsk_transform_to_2d_components(
        self_: *mut GskTransform,
        out_skew_x: *mut c_float,
        out_skew_y: *mut c_float,
        out_scale_x: *mut c_float,
        out_scale_y: *mut c_float,
        out_angle: *mut c_float,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    pub fn gsk_transform_to_affine(
        self_: *mut GskTransform,
        out_scale_x: *mut c_float,
        out_scale_y: *mut c_float,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    pub fn gsk_transform_to_matrix(
        self_: *mut GskTransform,
        out_matrix: *mut graphene::graphene_matrix_t,
    );
    pub fn gsk_transform_to_string(self_: *mut GskTransform) -> *mut c_char;
    pub fn gsk_transform_to_translate(
        self_: *mut GskTransform,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    pub fn gsk_transform_transform(
        next: *mut GskTransform,
        other: *mut GskTransform,
    ) -> *mut GskTransform;
    pub fn gsk_transform_transform_bounds(
        self_: *mut GskTransform,
        rect: *const graphene::graphene_rect_t,
        out_rect: *mut graphene::graphene_rect_t,
    );
    pub fn gsk_transform_transform_point(
        self_: *mut GskTransform,
        point: *const graphene::graphene_point_t,
        out_point: *mut graphene::graphene_point_t,
    );
    pub fn gsk_transform_translate(
        next: *mut GskTransform,
        point: *const graphene::graphene_point_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_translate_3d(
        next: *mut GskTransform,
        point: *const graphene::graphene_point3d_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_unref(self_: *mut GskTransform);
    pub fn gsk_transform_parse(
        string: *const c_char,
        out_transform: *mut *mut GskTransform,
    ) -> gboolean;

    //=========================================================================
    // GskBlendNode
    //=========================================================================
    pub fn gsk_blend_node_get_type() -> GType;
    pub fn gsk_blend_node_new(
        bottom: *mut GskRenderNode,
        top: *mut GskRenderNode,
        blend_mode: GskBlendMode,
    ) -> *mut GskBlendNode;
    pub fn gsk_blend_node_get_blend_mode(node: *const GskBlendNode) -> GskBlendMode;
    pub fn gsk_blend_node_get_bottom_child(node: *const GskBlendNode) -> *mut GskRenderNode;
    pub fn gsk_blend_node_get_top_child(node: *const GskBlendNode) -> *mut GskRenderNode;

    //=========================================================================
    // GskBlurNode
    //=========================================================================
    pub fn gsk_blur_node_get_type() -> GType;
    pub fn gsk_blur_node_new(child: *mut GskRenderNode, radius: c_float) -> *mut GskBlurNode;
    pub fn gsk_blur_node_get_child(node: *const GskBlurNode) -> *mut GskRenderNode;
    pub fn gsk_blur_node_get_radius(node: *const GskBlurNode) -> c_float;

    //=========================================================================
    // GskBorderNode
    //=========================================================================
    pub fn gsk_border_node_get_type() -> GType;
    pub fn gsk_border_node_new(
        outline: *const GskRoundedRect,
        border_width: *const [c_float; 4],
        border_color: *const [gdk::GdkRGBA; 4],
    ) -> *mut GskBorderNode;
    pub fn gsk_border_node_get_colors(node: *const GskBorderNode) -> *const [gdk::GdkRGBA; 4];
    pub fn gsk_border_node_get_outline(node: *const GskBorderNode) -> *const GskRoundedRect;
    pub fn gsk_border_node_get_widths(node: *const GskBorderNode) -> *const [c_float; 4];

    //=========================================================================
    // GskBroadwayRenderer
    //=========================================================================
    #[cfg(feature = "broadway")]
    #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
    pub fn gsk_broadway_renderer_get_type() -> GType;
    #[cfg(feature = "broadway")]
    #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
    pub fn gsk_broadway_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskCairoNode
    //=========================================================================
    pub fn gsk_cairo_node_get_type() -> GType;
    pub fn gsk_cairo_node_new(bounds: *const graphene::graphene_rect_t) -> *mut GskCairoNode;
    pub fn gsk_cairo_node_get_draw_context(node: *mut GskCairoNode) -> *mut cairo::cairo_t;
    pub fn gsk_cairo_node_get_surface(node: *mut GskCairoNode) -> *mut cairo::cairo_surface_t;

    //=========================================================================
    // GskCairoRenderer
    //=========================================================================
    pub fn gsk_cairo_renderer_get_type() -> GType;
    pub fn gsk_cairo_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskClipNode
    //=========================================================================
    pub fn gsk_clip_node_get_type() -> GType;
    pub fn gsk_clip_node_new(
        child: *mut GskRenderNode,
        clip: *const graphene::graphene_rect_t,
    ) -> *mut GskClipNode;
    pub fn gsk_clip_node_get_child(node: *const GskClipNode) -> *mut GskRenderNode;
    pub fn gsk_clip_node_get_clip(node: *const GskClipNode) -> *const graphene::graphene_rect_t;

    //=========================================================================
    // GskColorMatrixNode
    //=========================================================================
    pub fn gsk_color_matrix_node_get_type() -> GType;
    pub fn gsk_color_matrix_node_new(
        child: *mut GskRenderNode,
        color_matrix: *const graphene::graphene_matrix_t,
        color_offset: *const graphene::graphene_vec4_t,
    ) -> *mut GskColorMatrixNode;
    pub fn gsk_color_matrix_node_get_child(node: *const GskColorMatrixNode) -> *mut GskRenderNode;
    pub fn gsk_color_matrix_node_get_color_matrix(
        node: *const GskColorMatrixNode,
    ) -> *const graphene::graphene_matrix_t;
    pub fn gsk_color_matrix_node_get_color_offset(
        node: *const GskColorMatrixNode,
    ) -> *const graphene::graphene_vec4_t;

    //=========================================================================
    // GskColorNode
    //=========================================================================
    pub fn gsk_color_node_get_type() -> GType;
    pub fn gsk_color_node_new(
        rgba: *const gdk::GdkRGBA,
        bounds: *const graphene::graphene_rect_t,
    ) -> *mut GskColorNode;
    pub fn gsk_color_node_get_color(node: *const GskColorNode) -> *const gdk::GdkRGBA;

    //=========================================================================
    // GskComponentTransferNode
    //=========================================================================
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_node_get_type() -> GType;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_node_new(
        child: *mut GskRenderNode,
        r: *const GskComponentTransfer,
        g: *const GskComponentTransfer,
        b: *const GskComponentTransfer,
        a: *const GskComponentTransfer,
    ) -> *mut GskComponentTransferNode;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_node_get_child(
        node: *const GskComponentTransferNode,
    ) -> *mut GskRenderNode;
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    pub fn gsk_component_transfer_node_get_transfer(
        node: *const GskComponentTransferNode,
        component: c_uint,
    ) -> *const GskComponentTransfer;

    //=========================================================================
    // GskConicGradientNode
    //=========================================================================
    pub fn gsk_conic_gradient_node_get_type() -> GType;
    pub fn gsk_conic_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        center: *const graphene::graphene_point_t,
        rotation: c_float,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskConicGradientNode;
    #[cfg(feature = "v4_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
    pub fn gsk_conic_gradient_node_get_angle(node: *const GskConicGradientNode) -> c_float;
    pub fn gsk_conic_gradient_node_get_center(
        node: *const GskConicGradientNode,
    ) -> *const graphene::graphene_point_t;
    pub fn gsk_conic_gradient_node_get_color_stops(
        node: *const GskConicGradientNode,
        n_stops: *mut size_t,
    ) -> *const GskColorStop;
    pub fn gsk_conic_gradient_node_get_n_color_stops(node: *const GskConicGradientNode) -> size_t;
    pub fn gsk_conic_gradient_node_get_rotation(node: *const GskConicGradientNode) -> c_float;

    //=========================================================================
    // GskContainerNode
    //=========================================================================
    pub fn gsk_container_node_get_type() -> GType;
    pub fn gsk_container_node_new(
        children: *mut *mut GskRenderNode,
        n_children: c_uint,
    ) -> *mut GskContainerNode;
    pub fn gsk_container_node_get_child(
        node: *const GskContainerNode,
        idx: c_uint,
    ) -> *mut GskRenderNode;
    pub fn gsk_container_node_get_n_children(node: *const GskContainerNode) -> c_uint;

    //=========================================================================
    // GskCrossFadeNode
    //=========================================================================
    pub fn gsk_cross_fade_node_get_type() -> GType;
    pub fn gsk_cross_fade_node_new(
        start: *mut GskRenderNode,
        end: *mut GskRenderNode,
        progress: c_float,
    ) -> *mut GskCrossFadeNode;
    pub fn gsk_cross_fade_node_get_end_child(node: *const GskCrossFadeNode) -> *mut GskRenderNode;
    pub fn gsk_cross_fade_node_get_progress(node: *const GskCrossFadeNode) -> c_float;
    pub fn gsk_cross_fade_node_get_start_child(node: *const GskCrossFadeNode)
        -> *mut GskRenderNode;

    //=========================================================================
    // GskDebugNode
    //=========================================================================
    pub fn gsk_debug_node_get_type() -> GType;
    pub fn gsk_debug_node_new(child: *mut GskRenderNode, message: *mut c_char)
        -> *mut GskDebugNode;
    pub fn gsk_debug_node_get_child(node: *const GskDebugNode) -> *mut GskRenderNode;
    pub fn gsk_debug_node_get_message(node: *const GskDebugNode) -> *const c_char;

    //=========================================================================
    // GskFillNode
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_fill_node_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_fill_node_new(
        child: *mut GskRenderNode,
        path: *mut GskPath,
        fill_rule: GskFillRule,
    ) -> *mut GskFillNode;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_fill_node_get_child(node: *const GskFillNode) -> *mut GskRenderNode;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_fill_node_get_fill_rule(node: *const GskFillNode) -> GskFillRule;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_fill_node_get_path(node: *const GskFillNode) -> *mut GskPath;

    //=========================================================================
    // GskGLRenderer
    //=========================================================================
    #[cfg(feature = "v4_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
    pub fn gsk_gl_renderer_get_type() -> GType;
    #[cfg(feature = "v4_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
    pub fn gsk_gl_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskGLShader
    //=========================================================================
    pub fn gsk_gl_shader_get_type() -> GType;
    pub fn gsk_gl_shader_new_from_bytes(sourcecode: *mut glib::GBytes) -> *mut GskGLShader;
    pub fn gsk_gl_shader_new_from_resource(resource_path: *const c_char) -> *mut GskGLShader;
    pub fn gsk_gl_shader_compile(
        shader: *mut GskGLShader,
        renderer: *mut GskRenderer,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gsk_gl_shader_find_uniform_by_name(
        shader: *mut GskGLShader,
        name: *const c_char,
    ) -> c_int;
    pub fn gsk_gl_shader_format_args(shader: *mut GskGLShader, ...) -> *mut glib::GBytes;
    //pub fn gsk_gl_shader_format_args_va(shader: *mut GskGLShader, uniforms: /*Unimplemented*/va_list) -> *mut glib::GBytes;
    pub fn gsk_gl_shader_get_arg_bool(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> gboolean;
    pub fn gsk_gl_shader_get_arg_float(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> c_float;
    pub fn gsk_gl_shader_get_arg_int(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> i32;
    pub fn gsk_gl_shader_get_arg_uint(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> u32;
    pub fn gsk_gl_shader_get_arg_vec2(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
        out_value: *mut graphene::graphene_vec2_t,
    );
    pub fn gsk_gl_shader_get_arg_vec3(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
        out_value: *mut graphene::graphene_vec3_t,
    );
    pub fn gsk_gl_shader_get_arg_vec4(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
        out_value: *mut graphene::graphene_vec4_t,
    );
    pub fn gsk_gl_shader_get_args_size(shader: *mut GskGLShader) -> size_t;
    pub fn gsk_gl_shader_get_n_textures(shader: *mut GskGLShader) -> c_int;
    pub fn gsk_gl_shader_get_n_uniforms(shader: *mut GskGLShader) -> c_int;
    pub fn gsk_gl_shader_get_resource(shader: *mut GskGLShader) -> *const c_char;
    pub fn gsk_gl_shader_get_source(shader: *mut GskGLShader) -> *mut glib::GBytes;
    pub fn gsk_gl_shader_get_uniform_name(shader: *mut GskGLShader, idx: c_int) -> *const c_char;
    pub fn gsk_gl_shader_get_uniform_offset(shader: *mut GskGLShader, idx: c_int) -> c_int;
    pub fn gsk_gl_shader_get_uniform_type(shader: *mut GskGLShader, idx: c_int)
        -> GskGLUniformType;

    //=========================================================================
    // GskGLShaderNode
    //=========================================================================
    pub fn gsk_gl_shader_node_get_type() -> GType;
    pub fn gsk_gl_shader_node_new(
        shader: *mut GskGLShader,
        bounds: *const graphene::graphene_rect_t,
        args: *mut glib::GBytes,
        children: *mut *mut GskRenderNode,
        n_children: c_uint,
    ) -> *mut GskGLShaderNode;
    pub fn gsk_gl_shader_node_get_args(node: *const GskGLShaderNode) -> *mut glib::GBytes;
    pub fn gsk_gl_shader_node_get_child(
        node: *const GskGLShaderNode,
        idx: c_uint,
    ) -> *mut GskRenderNode;
    pub fn gsk_gl_shader_node_get_n_children(node: *const GskGLShaderNode) -> c_uint;
    pub fn gsk_gl_shader_node_get_shader(node: *const GskGLShaderNode) -> *mut GskGLShader;

    //=========================================================================
    // GskInsetShadowNode
    //=========================================================================
    pub fn gsk_inset_shadow_node_get_type() -> GType;
    pub fn gsk_inset_shadow_node_new(
        outline: *const GskRoundedRect,
        color: *const gdk::GdkRGBA,
        dx: c_float,
        dy: c_float,
        spread: c_float,
        blur_radius: c_float,
    ) -> *mut GskInsetShadowNode;
    pub fn gsk_inset_shadow_node_get_blur_radius(node: *const GskInsetShadowNode) -> c_float;
    pub fn gsk_inset_shadow_node_get_color(node: *const GskInsetShadowNode) -> *const gdk::GdkRGBA;
    pub fn gsk_inset_shadow_node_get_dx(node: *const GskInsetShadowNode) -> c_float;
    pub fn gsk_inset_shadow_node_get_dy(node: *const GskInsetShadowNode) -> c_float;
    pub fn gsk_inset_shadow_node_get_outline(
        node: *const GskInsetShadowNode,
    ) -> *const GskRoundedRect;
    pub fn gsk_inset_shadow_node_get_spread(node: *const GskInsetShadowNode) -> c_float;

    //=========================================================================
    // GskLinearGradientNode
    //=========================================================================
    pub fn gsk_linear_gradient_node_get_type() -> GType;
    pub fn gsk_linear_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        start: *const graphene::graphene_point_t,
        end: *const graphene::graphene_point_t,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskLinearGradientNode;
    pub fn gsk_linear_gradient_node_get_color_stops(
        node: *const GskLinearGradientNode,
        n_stops: *mut size_t,
    ) -> *const GskColorStop;
    pub fn gsk_linear_gradient_node_get_end(
        node: *const GskLinearGradientNode,
    ) -> *const graphene::graphene_point_t;
    pub fn gsk_linear_gradient_node_get_n_color_stops(node: *const GskLinearGradientNode)
        -> size_t;
    pub fn gsk_linear_gradient_node_get_start(
        node: *const GskLinearGradientNode,
    ) -> *const graphene::graphene_point_t;

    //=========================================================================
    // GskMaskNode
    //=========================================================================
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_mask_node_get_type() -> GType;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_mask_node_new(
        source: *mut GskRenderNode,
        mask: *mut GskRenderNode,
        mask_mode: GskMaskMode,
    ) -> *mut GskMaskNode;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_mask_node_get_mask(node: *const GskMaskNode) -> *mut GskRenderNode;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_mask_node_get_mask_mode(node: *const GskMaskNode) -> GskMaskMode;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_mask_node_get_source(node: *const GskMaskNode) -> *mut GskRenderNode;

    //=========================================================================
    // GskNglRenderer
    //=========================================================================
    pub fn gsk_ngl_renderer_get_type() -> GType;
    pub fn gsk_ngl_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskOpacityNode
    //=========================================================================
    pub fn gsk_opacity_node_get_type() -> GType;
    pub fn gsk_opacity_node_new(child: *mut GskRenderNode, opacity: c_float)
        -> *mut GskOpacityNode;
    pub fn gsk_opacity_node_get_child(node: *const GskOpacityNode) -> *mut GskRenderNode;
    pub fn gsk_opacity_node_get_opacity(node: *const GskOpacityNode) -> c_float;

    //=========================================================================
    // GskOutsetShadowNode
    //=========================================================================
    pub fn gsk_outset_shadow_node_get_type() -> GType;
    pub fn gsk_outset_shadow_node_new(
        outline: *const GskRoundedRect,
        color: *const gdk::GdkRGBA,
        dx: c_float,
        dy: c_float,
        spread: c_float,
        blur_radius: c_float,
    ) -> *mut GskOutsetShadowNode;
    pub fn gsk_outset_shadow_node_get_blur_radius(node: *const GskOutsetShadowNode) -> c_float;
    pub fn gsk_outset_shadow_node_get_color(
        node: *const GskOutsetShadowNode,
    ) -> *const gdk::GdkRGBA;
    pub fn gsk_outset_shadow_node_get_dx(node: *const GskOutsetShadowNode) -> c_float;
    pub fn gsk_outset_shadow_node_get_dy(node: *const GskOutsetShadowNode) -> c_float;
    pub fn gsk_outset_shadow_node_get_outline(
        node: *const GskOutsetShadowNode,
    ) -> *const GskRoundedRect;
    pub fn gsk_outset_shadow_node_get_spread(node: *const GskOutsetShadowNode) -> c_float;

    //=========================================================================
    // GskRadialGradientNode
    //=========================================================================
    pub fn gsk_radial_gradient_node_get_type() -> GType;
    pub fn gsk_radial_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        center: *const graphene::graphene_point_t,
        hradius: c_float,
        vradius: c_float,
        start: c_float,
        end: c_float,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskRadialGradientNode;
    pub fn gsk_radial_gradient_node_get_center(
        node: *const GskRadialGradientNode,
    ) -> *const graphene::graphene_point_t;
    pub fn gsk_radial_gradient_node_get_color_stops(
        node: *const GskRadialGradientNode,
        n_stops: *mut size_t,
    ) -> *const GskColorStop;
    pub fn gsk_radial_gradient_node_get_end(node: *const GskRadialGradientNode) -> c_float;
    pub fn gsk_radial_gradient_node_get_hradius(node: *const GskRadialGradientNode) -> c_float;
    pub fn gsk_radial_gradient_node_get_n_color_stops(node: *const GskRadialGradientNode)
        -> size_t;
    pub fn gsk_radial_gradient_node_get_start(node: *const GskRadialGradientNode) -> c_float;
    pub fn gsk_radial_gradient_node_get_vradius(node: *const GskRadialGradientNode) -> c_float;

    //=========================================================================
    // GskRenderNode
    //=========================================================================
    pub fn gsk_render_node_get_type() -> GType;
    pub fn gsk_render_node_deserialize(
        bytes: *mut glib::GBytes,
        error_func: GskParseErrorFunc,
        user_data: gpointer,
    ) -> *mut GskRenderNode;
    pub fn gsk_render_node_draw(node: *mut GskRenderNode, cr: *mut cairo::cairo_t);
    pub fn gsk_render_node_get_bounds(
        node: *mut GskRenderNode,
        bounds: *mut graphene::graphene_rect_t,
    );
    pub fn gsk_render_node_get_node_type(node: *const GskRenderNode) -> GskRenderNodeType;
    #[cfg(feature = "v4_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
    pub fn gsk_render_node_get_opaque_rect(
        self_: *mut GskRenderNode,
        out_opaque: *mut graphene::graphene_rect_t,
    ) -> gboolean;
    pub fn gsk_render_node_ref(node: *mut GskRenderNode) -> *mut GskRenderNode;
    pub fn gsk_render_node_serialize(node: *mut GskRenderNode) -> *mut glib::GBytes;
    pub fn gsk_render_node_unref(node: *mut GskRenderNode);
    pub fn gsk_render_node_write_to_file(
        node: *mut GskRenderNode,
        filename: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // GskRenderer
    //=========================================================================
    pub fn gsk_renderer_get_type() -> GType;
    pub fn gsk_renderer_new_for_surface(surface: *mut gdk::GdkSurface) -> *mut GskRenderer;
    pub fn gsk_renderer_get_surface(renderer: *mut GskRenderer) -> *mut gdk::GdkSurface;
    pub fn gsk_renderer_is_realized(renderer: *mut GskRenderer) -> gboolean;
    pub fn gsk_renderer_realize(
        renderer: *mut GskRenderer,
        surface: *mut gdk::GdkSurface,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_renderer_realize_for_display(
        renderer: *mut GskRenderer,
        display: *mut gdk::GdkDisplay,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gsk_renderer_render(
        renderer: *mut GskRenderer,
        root: *mut GskRenderNode,
        region: *const cairo::cairo_region_t,
    );
    pub fn gsk_renderer_render_texture(
        renderer: *mut GskRenderer,
        root: *mut GskRenderNode,
        viewport: *const graphene::graphene_rect_t,
    ) -> *mut gdk::GdkTexture;
    pub fn gsk_renderer_unrealize(renderer: *mut GskRenderer);

    //=========================================================================
    // GskRepeatNode
    //=========================================================================
    pub fn gsk_repeat_node_get_type() -> GType;
    pub fn gsk_repeat_node_new(
        bounds: *const graphene::graphene_rect_t,
        child: *mut GskRenderNode,
        child_bounds: *const graphene::graphene_rect_t,
    ) -> *mut GskRepeatNode;
    pub fn gsk_repeat_node_get_child(node: *const GskRepeatNode) -> *mut GskRenderNode;
    pub fn gsk_repeat_node_get_child_bounds(
        node: *const GskRepeatNode,
    ) -> *const graphene::graphene_rect_t;

    //=========================================================================
    // GskRepeatingLinearGradientNode
    //=========================================================================
    pub fn gsk_repeating_linear_gradient_node_get_type() -> GType;
    pub fn gsk_repeating_linear_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        start: *const graphene::graphene_point_t,
        end: *const graphene::graphene_point_t,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskRepeatingLinearGradientNode;

    //=========================================================================
    // GskRepeatingRadialGradientNode
    //=========================================================================
    pub fn gsk_repeating_radial_gradient_node_get_type() -> GType;
    pub fn gsk_repeating_radial_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        center: *const graphene::graphene_point_t,
        hradius: c_float,
        vradius: c_float,
        start: c_float,
        end: c_float,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskRepeatingRadialGradientNode;

    //=========================================================================
    // GskRoundedClipNode
    //=========================================================================
    pub fn gsk_rounded_clip_node_get_type() -> GType;
    pub fn gsk_rounded_clip_node_new(
        child: *mut GskRenderNode,
        clip: *const GskRoundedRect,
    ) -> *mut GskRoundedClipNode;
    pub fn gsk_rounded_clip_node_get_child(node: *const GskRoundedClipNode) -> *mut GskRenderNode;
    pub fn gsk_rounded_clip_node_get_clip(node: *const GskRoundedClipNode)
        -> *const GskRoundedRect;

    //=========================================================================
    // GskShadowNode
    //=========================================================================
    pub fn gsk_shadow_node_get_type() -> GType;
    pub fn gsk_shadow_node_new(
        child: *mut GskRenderNode,
        shadows: *const GskShadow,
        n_shadows: size_t,
    ) -> *mut GskShadowNode;
    pub fn gsk_shadow_node_get_child(node: *const GskShadowNode) -> *mut GskRenderNode;
    pub fn gsk_shadow_node_get_n_shadows(node: *const GskShadowNode) -> size_t;
    pub fn gsk_shadow_node_get_shadow(node: *const GskShadowNode, i: size_t) -> *const GskShadow;

    //=========================================================================
    // GskStrokeNode
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_node_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_node_new(
        child: *mut GskRenderNode,
        path: *mut GskPath,
        stroke: *const GskStroke,
    ) -> *mut GskStrokeNode;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_node_get_child(node: *const GskStrokeNode) -> *mut GskRenderNode;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_node_get_path(node: *const GskStrokeNode) -> *mut GskPath;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_stroke_node_get_stroke(node: *const GskStrokeNode) -> *const GskStroke;

    //=========================================================================
    // GskSubsurfaceNode
    //=========================================================================
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_subsurface_node_get_type() -> GType;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_subsurface_node_new(
        child: *mut GskRenderNode,
        subsurface: gpointer,
    ) -> *mut GskSubsurfaceNode;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_subsurface_node_get_subsurface(node: *const GskDebugNode) -> gpointer;
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn gsk_subsurface_node_get_child(node: *const GskSubsurfaceNode) -> *mut GskRenderNode;

    //=========================================================================
    // GskTextNode
    //=========================================================================
    pub fn gsk_text_node_get_type() -> GType;
    pub fn gsk_text_node_new(
        font: *mut pango::PangoFont,
        glyphs: *mut pango::PangoGlyphString,
        color: *const gdk::GdkRGBA,
        offset: *const graphene::graphene_point_t,
    ) -> *mut GskTextNode;
    pub fn gsk_text_node_get_color(node: *const GskTextNode) -> *const gdk::GdkRGBA;
    pub fn gsk_text_node_get_font(node: *const GskTextNode) -> *mut pango::PangoFont;
    pub fn gsk_text_node_get_glyphs(
        node: *const GskTextNode,
        n_glyphs: *mut c_uint,
    ) -> *const pango::PangoGlyphInfo;
    pub fn gsk_text_node_get_num_glyphs(node: *const GskTextNode) -> c_uint;
    pub fn gsk_text_node_get_offset(node: *const GskTextNode) -> *const graphene::graphene_point_t;
    #[cfg(feature = "v4_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
    pub fn gsk_text_node_has_color_glyphs(node: *const GskTextNode) -> gboolean;

    //=========================================================================
    // GskTextureNode
    //=========================================================================
    pub fn gsk_texture_node_get_type() -> GType;
    pub fn gsk_texture_node_new(
        texture: *mut gdk::GdkTexture,
        bounds: *const graphene::graphene_rect_t,
    ) -> *mut GskTextureNode;
    pub fn gsk_texture_node_get_texture(node: *const GskTextureNode) -> *mut gdk::GdkTexture;

    //=========================================================================
    // GskTextureScaleNode
    //=========================================================================
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_texture_scale_node_get_type() -> GType;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_texture_scale_node_new(
        texture: *mut gdk::GdkTexture,
        bounds: *const graphene::graphene_rect_t,
        filter: GskScalingFilter,
    ) -> *mut GskTextureScaleNode;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_texture_scale_node_get_filter(node: *const GskTextureScaleNode) -> GskScalingFilter;
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    pub fn gsk_texture_scale_node_get_texture(
        node: *const GskTextureScaleNode,
    ) -> *mut gdk::GdkTexture;

    //=========================================================================
    // GskTransformNode
    //=========================================================================
    pub fn gsk_transform_node_get_type() -> GType;
    pub fn gsk_transform_node_new(
        child: *mut GskRenderNode,
        transform: *mut GskTransform,
    ) -> *mut GskTransformNode;
    pub fn gsk_transform_node_get_child(node: *const GskTransformNode) -> *mut GskRenderNode;
    pub fn gsk_transform_node_get_transform(node: *const GskTransformNode) -> *mut GskTransform;

    //=========================================================================
    // GskVulkanRenderer
    //=========================================================================
    #[cfg(feature = "vulkan")]
    #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
    pub fn gsk_vulkan_renderer_get_type() -> GType;
    #[cfg(feature = "vulkan")]
    #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
    pub fn gsk_vulkan_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // Other functions
    //=========================================================================
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    pub fn gsk_value_dup_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    pub fn gsk_value_get_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    pub fn gsk_value_set_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
    #[cfg(feature = "v4_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
    pub fn gsk_value_take_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);

}
