quote
$(Expr(:toplevel, quote
    function contains_point(instance::RoundedRect, _point::Union{GraphenePoint, Ref{_GraphenePoint}})
        ret = ccall(("gsk_rounded_rect_contains_point", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GraphenePoint}), instance, _point)
        ret2 = convert(Bool, ret)
        ret2
    end
    function contains_rect(instance::RoundedRect, _rect::Union{GrapheneRect, Ref{_GrapheneRect}})
        ret = ccall(("gsk_rounded_rect_contains_rect", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}), instance, _rect)
        ret2 = convert(Bool, ret)
        ret2
    end
    function init(instance::RoundedRect, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _top_left::Union{GrapheneSize, Ref{_GrapheneSize}}, _top_right::Union{GrapheneSize, Ref{_GrapheneSize}}, _bottom_right::Union{GrapheneSize, Ref{_GrapheneSize}}, _bottom_left::Union{GrapheneSize, Ref{_GrapheneSize}})
        ret = ccall(("gsk_rounded_rect_init", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}, Ptr{_GrapheneSize}, Ptr{_GrapheneSize}, Ptr{_GrapheneSize}, Ptr{_GrapheneSize}), instance, _bounds, _top_left, _top_right, _bottom_right, _bottom_left)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function init_copy(instance::RoundedRect, _src::_GskRoundedRect)
        ret = ccall(("gsk_rounded_rect_init_copy", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GskRoundedRect}), instance, _src)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function init_from_rect(instance::RoundedRect, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _radius::Real)
        ret = ccall(("gsk_rounded_rect_init_from_rect", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}, Float32), instance, _bounds, _radius)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function intersects_rect(instance::RoundedRect, _rect::Union{GrapheneRect, Ref{_GrapheneRect}})
        ret = ccall(("gsk_rounded_rect_intersects_rect", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}), instance, _rect)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_rectilinear(instance::RoundedRect)
        ret = ccall(("gsk_rounded_rect_is_rectilinear", libgtk4), Cint, (Ptr{_GskRoundedRect},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function normalize(instance::RoundedRect)
        ret = ccall(("gsk_rounded_rect_normalize", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect},), instance)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function offset(instance::RoundedRect, _dx::Real, _dy::Real)
        ret = ccall(("gsk_rounded_rect_offset", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Float32, Float32), instance, _dx, _dy)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function shrink(instance::RoundedRect, _top::Real, _right::Real, _bottom::Real, _left::Real)
        ret = ccall(("gsk_rounded_rect_shrink", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Float32, Float32, Float32, Float32), instance, _top, _right, _bottom, _left)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function ShaderArgsBuilder_new(_shader::GskGLShader, _initial_values::Maybe(GBytes))
        _initial_values = nothing_to_null(_initial_values)
        ret = ccall(("gsk_shader_args_builder_new", libgtk4), Ptr{GskShaderArgsBuilder}, (Ptr{GObject}, Ptr{GBytes}), _shader, _initial_values)
        ret2 = convert(GskShaderArgsBuilder, ret, true)
        ret2
    end
    function ref(instance::GskShaderArgsBuilder)
        ret = ccall(("gsk_shader_args_builder_ref", libgtk4), Ptr{GskShaderArgsBuilder}, (Ptr{GskShaderArgsBuilder},), instance)
        ret2 = convert(GskShaderArgsBuilder, ret, true)
        ret2
    end
    function set_bool(instance::GskShaderArgsBuilder, _idx::Integer, _value::Bool)
        ret = ccall(("gsk_shader_args_builder_set_bool", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Cint), instance, _idx, _value)
        nothing
    end
    function set_float(instance::GskShaderArgsBuilder, _idx::Integer, _value::Real)
        ret = ccall(("gsk_shader_args_builder_set_float", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Float32), instance, _idx, _value)
        nothing
    end
    function set_int(instance::GskShaderArgsBuilder, _idx::Integer, _value::Integer)
        ret = ccall(("gsk_shader_args_builder_set_int", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Int32), instance, _idx, _value)
        nothing
    end
    function set_uint(instance::GskShaderArgsBuilder, _idx::Integer, _value::Integer)
        ret = ccall(("gsk_shader_args_builder_set_uint", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, UInt32), instance, _idx, _value)
        nothing
    end
    function set_vec2(instance::GskShaderArgsBuilder, _idx::Integer, _value::Union{GrapheneVec2, Ref{_GrapheneVec2}})
        ret = ccall(("gsk_shader_args_builder_set_vec2", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Ptr{_GrapheneVec2}), instance, _idx, _value)
        nothing
    end
    function set_vec3(instance::GskShaderArgsBuilder, _idx::Integer, _value::Union{GrapheneVec3, Ref{_GrapheneVec3}})
        ret = ccall(("gsk_shader_args_builder_set_vec3", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Ptr{_GrapheneVec3}), instance, _idx, _value)
        nothing
    end
    function set_vec4(instance::GskShaderArgsBuilder, _idx::Integer, _value::Union{GrapheneVec4, Ref{_GrapheneVec4}})
        ret = ccall(("gsk_shader_args_builder_set_vec4", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder}, Int32, Ptr{_GrapheneVec4}), instance, _idx, _value)
        nothing
    end
    function to_args(instance::GskShaderArgsBuilder)
        ret = ccall(("gsk_shader_args_builder_to_args", libgtk4), Ptr{GBytes}, (Ptr{GskShaderArgsBuilder},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function unref(instance::GskShaderArgsBuilder)
        ret = ccall(("gsk_shader_args_builder_unref", libgtk4), Nothing, (Ptr{GskShaderArgsBuilder},), instance)
        nothing
    end
    function Transform_new()
        ret = ccall(("gsk_transform_new", libgtk4), Ptr{GskTransform}, ())
        ret2 = convert(GskTransform, ret, true)
        ret2
    end
    function equal(instance::GskTransform, _second::Maybe(GskTransform))
        _second = nothing_to_null(_second)
        ret = ccall(("gsk_transform_equal", libgtk4), Cint, (Ptr{GskTransform}, Ptr{GskTransform}), instance, _second)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_category(instance::GskTransform)
        ret = ccall(("gsk_transform_get_category", libgtk4), UInt32, (Ptr{GskTransform},), instance)
        ret2 = TransformCategory(ret)
        ret2
    end
    function invert(instance::GskTransform)
        ret = ccall(("gsk_transform_invert", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform},), instance)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function matrix(instance::GskTransform, _matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}})
        ret = ccall(("gsk_transform_matrix", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GrapheneMatrix}), instance, _matrix)
        ret2 = convert(GskTransform, ret, true)
        ret2
    end
    function perspective(instance::GskTransform, _depth::Real)
        ret = ccall(("gsk_transform_perspective", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32), instance, _depth)
        ret2 = convert(GskTransform, ret, true)
        ret2
    end
    function print(instance::GskTransform, _string::Union{GString, Ref{_GString}})
        ret = ccall(("gsk_transform_print", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GString}), instance, _string)
        nothing
    end
    function ref(instance::GskTransform)
        ret = ccall(("gsk_transform_ref", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform},), instance)
        ret2 = convert_if_not_null(GskTransform, ret, false)
        ret2
    end
    function rotate(instance::GskTransform, _angle::Real)
        ret = ccall(("gsk_transform_rotate", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32), instance, _angle)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function rotate_3d(instance::GskTransform, _angle::Real, _axis::Union{GrapheneVec3, Ref{_GrapheneVec3}})
        ret = ccall(("gsk_transform_rotate_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Ptr{_GrapheneVec3}), instance, _angle, _axis)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function scale(instance::GskTransform, _factor_x::Real, _factor_y::Real)
        ret = ccall(("gsk_transform_scale", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Float32), instance, _factor_x, _factor_y)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function scale_3d(instance::GskTransform, _factor_x::Real, _factor_y::Real, _factor_z::Real)
        ret = ccall(("gsk_transform_scale_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Float32, Float32), instance, _factor_x, _factor_y, _factor_z)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function skew(instance::GskTransform, _skew_x::Real, _skew_y::Real)
        ret = ccall(("gsk_transform_skew", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Float32), instance, _skew_x, _skew_y)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function to_2d(instance::GskTransform)
        m_out_xx = Ref{Float32}()
        m_out_yx = Ref{Float32}()
        m_out_xy = Ref{Float32}()
        m_out_yy = Ref{Float32}()
        m_out_dx = Ref{Float32}()
        m_out_dy = Ref{Float32}()
        ret = ccall(("gsk_transform_to_2d", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}), instance, m_out_xx, m_out_yx, m_out_xy, m_out_yy, m_out_dx, m_out_dy)
        _out_xx = m_out_xx[]
        _out_yx = m_out_yx[]
        _out_xy = m_out_xy[]
        _out_yy = m_out_yy[]
        _out_dx = m_out_dx[]
        _out_dy = m_out_dy[]
        (_out_xx, _out_yx, _out_xy, _out_yy, _out_dx, _out_dy)
    end
    function to_2d_components(instance::GskTransform)
        m_out_skew_x = Ref{Float32}()
        m_out_skew_y = Ref{Float32}()
        m_out_scale_x = Ref{Float32}()
        m_out_scale_y = Ref{Float32}()
        m_out_angle = Ref{Float32}()
        m_out_dx = Ref{Float32}()
        m_out_dy = Ref{Float32}()
        ret = ccall(("gsk_transform_to_2d_components", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}), instance, m_out_skew_x, m_out_skew_y, m_out_scale_x, m_out_scale_y, m_out_angle, m_out_dx, m_out_dy)
        _out_skew_x = m_out_skew_x[]
        _out_skew_y = m_out_skew_y[]
        _out_scale_x = m_out_scale_x[]
        _out_scale_y = m_out_scale_y[]
        _out_angle = m_out_angle[]
        _out_dx = m_out_dx[]
        _out_dy = m_out_dy[]
        (_out_skew_x, _out_skew_y, _out_scale_x, _out_scale_y, _out_angle, _out_dx, _out_dy)
    end
    function to_affine(instance::GskTransform)
        m_out_scale_x = Ref{Float32}()
        m_out_scale_y = Ref{Float32}()
        m_out_dx = Ref{Float32}()
        m_out_dy = Ref{Float32}()
        ret = ccall(("gsk_transform_to_affine", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}, Ptr{Float32}), instance, m_out_scale_x, m_out_scale_y, m_out_dx, m_out_dy)
        _out_scale_x = m_out_scale_x[]
        _out_scale_y = m_out_scale_y[]
        _out_dx = m_out_dx[]
        _out_dy = m_out_dy[]
        (_out_scale_x, _out_scale_y, _out_dx, _out_dy)
    end
    function to_matrix(instance::GskTransform)
        m_out_matrix = Ref{_GrapheneMatrix}()
        ret = ccall(("gsk_transform_to_matrix", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GrapheneMatrix}), instance, m_out_matrix)
        _out_matrix = m_out_matrix[]
        _out_matrix
    end
    function to_string(instance::GskTransform)
        ret = ccall(("gsk_transform_to_string", libgtk4), Cstring, (Ptr{GskTransform},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function to_translate(instance::GskTransform)
        m_out_dx = Ref{Float32}()
        m_out_dy = Ref{Float32}()
        ret = ccall(("gsk_transform_to_translate", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{Float32}, Ptr{Float32}), instance, m_out_dx, m_out_dy)
        _out_dx = m_out_dx[]
        _out_dy = m_out_dy[]
        (_out_dx, _out_dy)
    end
    function transform(instance::GskTransform, _other::Maybe(GskTransform))
        _other = nothing_to_null(_other)
        ret = ccall(("gsk_transform_transform", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{GskTransform}), instance, _other)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function transform_bounds(instance::GskTransform, _rect::Union{GrapheneRect, Ref{_GrapheneRect}})
        m_out_rect = Ref{_GrapheneRect}()
        ret = ccall(("gsk_transform_transform_bounds", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GrapheneRect}, Ptr{_GrapheneRect}), instance, _rect, m_out_rect)
        _out_rect = m_out_rect[]
        _out_rect
    end
    function transform_point(instance::GskTransform, _point::Union{GraphenePoint, Ref{_GraphenePoint}})
        m_out_point = Ref{_GraphenePoint}()
        ret = ccall(("gsk_transform_transform_point", libgtk4), Nothing, (Ptr{GskTransform}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}), instance, _point, m_out_point)
        _out_point = m_out_point[]
        _out_point
    end
    function translate(instance::GskTransform, _point::Union{GraphenePoint, Ref{_GraphenePoint}})
        ret = ccall(("gsk_transform_translate", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GraphenePoint}), instance, _point)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function translate_3d(instance::GskTransform, _point::Union{GraphenePoint3D, Ref{_GraphenePoint3D}})
        ret = ccall(("gsk_transform_translate_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GraphenePoint3D}), instance, _point)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function unref(instance::GskTransform)
        ret = ccall(("gsk_transform_unref", libgtk4), Nothing, (Ptr{GskTransform},), instance)
        nothing
    end
    function BlendNode_new(_bottom::GskRenderNode, _top::GskRenderNode, _blend_mode)
        ret = ccall(("gsk_blend_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{GskRenderNode}, UInt32), _bottom, _top, _blend_mode)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_blend_mode(instance::GskBlendNode)
        ret = ccall(("gsk_blend_node_get_blend_mode", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret2 = BlendMode(ret)
        ret2
    end
    function get_bottom_child(instance::GskBlendNode)
        ret = ccall(("gsk_blend_node_get_bottom_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_top_child(instance::GskBlendNode)
        ret = ccall(("gsk_blend_node_get_top_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function BlurNode_new(_child::GskRenderNode, _radius::Real)
        ret = ccall(("gsk_blur_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Float32), _child, _radius)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskBlurNode)
        ret = ccall(("gsk_blur_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_radius(instance::GskBlurNode)
        ret = ccall(("gsk_blur_node_get_radius", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function BorderNode_new(_outline::_GskRoundedRect, _border_width, _border_color)
        _border_width = convert(Vector{Float32}, _border_width)
        _border_color = convert(Vector{_GdkRGBA}, _border_color)
        ret = ccall(("gsk_border_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{Float32}, Ptr{_GdkRGBA}), _outline, _border_width, _border_color)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_colors(instance::GskBorderNode)
        ret = ccall(("gsk_border_node_get_colors", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false)
        ret2
    end
    function get_outline(instance::GskBorderNode)
        ret = ccall(("gsk_border_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function get_widths(instance::GskBorderNode)
        ret = ccall(("gsk_border_node_get_widths", libgtk4), Ptr{Float32}, (Ptr{GskRenderNode},), instance)
        ret
    end
    function BroadwayRenderer_new()
        ret = ccall(("gsk_broadway_renderer_new", libgtk4), Ptr{GObject}, ())
        ret2 = convert(GskRenderer, ret, true)
        ret2
    end
    function CairoNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}})
        ret = ccall(("gsk_cairo_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect},), _bounds)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_draw_context(instance::GskCairoNode)
        ret = ccall(("gsk_cairo_node_get_draw_context", libgtk4), Ptr{cairoContext}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(cairoContext, ret, true)
        ret2
    end
    function get_surface(instance::GskCairoNode)
        ret = ccall(("gsk_cairo_node_get_surface", libgtk4), Ptr{cairoSurface}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(cairoSurface, ret, false)
        ret2
    end
    function CairoRenderer_new()
        ret = ccall(("gsk_cairo_renderer_new", libgtk4), Ptr{GObject}, ())
        ret2 = convert(GskRenderer, ret, true)
        ret2
    end
    function ClipNode_new(_child::GskRenderNode, _clip::Union{GrapheneRect, Ref{_GrapheneRect}})
        ret = ccall(("gsk_clip_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GrapheneRect}), _child, _clip)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskClipNode)
        ret = ccall(("gsk_clip_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_clip(instance::GskClipNode)
        ret = ccall(("gsk_clip_node_get_clip", libgtk4), Ptr{_GrapheneRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false)
        ret2
    end
    function ColorMatrixNode_new(_child::GskRenderNode, _color_matrix::Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, _color_offset::Union{GrapheneVec4, Ref{_GrapheneVec4}})
        ret = ccall(("gsk_color_matrix_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GrapheneMatrix}, Ptr{_GrapheneVec4}), _child, _color_matrix, _color_offset)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskColorMatrixNode)
        ret = ccall(("gsk_color_matrix_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_color_matrix(instance::GskColorMatrixNode)
        ret = ccall(("gsk_color_matrix_node_get_color_matrix", libgtk4), Ptr{_GrapheneMatrix}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GrapheneMatrix, Ref{_GrapheneMatrix}}, ret, false)
        ret2
    end
    function get_color_offset(instance::GskColorMatrixNode)
        ret = ccall(("gsk_color_matrix_node_get_color_offset", libgtk4), Ptr{_GrapheneVec4}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GrapheneVec4, Ref{_GrapheneVec4}}, ret, false)
        ret2
    end
    function ColorNode_new(_rgba::Union{GdkRGBA, Ref{_GdkRGBA}}, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}})
        ret = ccall(("gsk_color_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GdkRGBA}, Ptr{_GrapheneRect}), _rgba, _bounds)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_color(instance::GskColorNode)
        ret = ccall(("gsk_color_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false)
        ret2
    end
    function ConicGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _rotation::Real, _color_stops)
        _color_stops = convert(Vector{_GskColorStop}, _color_stops)
        _n_color_stops = length(_color_stops)
        ret = ccall(("gsk_conic_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Ptr{_GskColorStop}, UInt64), _bounds, _center, _rotation, _color_stops, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_angle(instance::GskConicGradientNode)
        ret = ccall(("gsk_conic_gradient_node_get_angle", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_center(instance::GskConicGradientNode)
        ret = ccall(("gsk_conic_gradient_node_get_center", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false)
        ret2
    end
    function get_color_stops(instance::GskConicGradientNode)
        m_n_stops = Ref{UInt64}()
        ret = ccall(("gsk_conic_gradient_node_get_color_stops", libgtk4), Ptr{_GskColorStop}, (Ptr{GskRenderNode}, Ptr{UInt64}), instance, m_n_stops)
        _n_stops = m_n_stops[]
        ret
    end
    function get_n_color_stops(instance::GskConicGradientNode)
        ret = ccall(("gsk_conic_gradient_node_get_n_color_stops", libgtk4), UInt64, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_rotation(instance::GskConicGradientNode)
        ret = ccall(("gsk_conic_gradient_node_get_rotation", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function ContainerNode_new(_children)
        _children = convert(Vector{Ptr{GskRenderNode}}, _children)
        _n_children = length(_children)
        ret = ccall(("gsk_container_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{Ptr{GskRenderNode}}, UInt32), _children, _n_children)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskContainerNode, _idx::Integer)
        ret = ccall(("gsk_container_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, UInt32), instance, _idx)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_n_children(instance::GskContainerNode)
        ret = ccall(("gsk_container_node_get_n_children", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function CrossFadeNode_new(_start::GskRenderNode, _end::GskRenderNode, _progress::Real)
        ret = ccall(("gsk_cross_fade_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{GskRenderNode}, Float32), _start, _end, _progress)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_end_child(instance::GskCrossFadeNode)
        ret = ccall(("gsk_cross_fade_node_get_end_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_progress(instance::GskCrossFadeNode)
        ret = ccall(("gsk_cross_fade_node_get_progress", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_start_child(instance::GskCrossFadeNode)
        ret = ccall(("gsk_cross_fade_node_get_start_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function DebugNode_new(_child::GskRenderNode, _message::Union{AbstractString, Symbol})
        ret = ccall(("gsk_debug_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Cstring), _child, _message)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskDebugNode)
        ret = ccall(("gsk_debug_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_message(instance::GskDebugNode)
        ret = ccall(("gsk_debug_node_get_message", libgtk4), Cstring, (Ptr{GskRenderNode},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function GLRenderer_new()
        ret = ccall(("gsk_gl_renderer_new", libgtk4), Ptr{GObject}, ())
        ret2 = convert(GskRenderer, ret, true)
        ret2
    end
    function GLShader_new_from_bytes(_sourcecode::GBytes)
        ret = ccall(("gsk_gl_shader_new_from_bytes", libgtk4), Ptr{GObject}, (Ptr{GBytes},), _sourcecode)
        ret2 = convert(GskGLShader, ret, true)
        ret2
    end
    function GLShader_new_from_resource(_resource_path::Union{AbstractString, Symbol})
        ret = ccall(("gsk_gl_shader_new_from_resource", libgtk4), Ptr{GObject}, (Cstring,), _resource_path)
        ret2 = convert(GskGLShader, ret, true)
        ret2
    end
    function compile(instance::GskGLShader, _renderer::GskRenderer)
        err = err_buf()
        ret = ccall(("gsk_gl_shader_compile", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _renderer, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function find_uniform_by_name(instance::GskGLShader, _name::Union{AbstractString, Symbol})
        ret = ccall(("gsk_gl_shader_find_uniform_by_name", libgtk4), Int32, (Ptr{GObject}, Cstring), instance, _name)
        ret
    end
    function get_arg_bool(instance::GskGLShader, _args::GBytes, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_arg_bool", libgtk4), Cint, (Ptr{GObject}, Ptr{GBytes}, Int32), instance, _args, _idx)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_arg_float(instance::GskGLShader, _args::GBytes, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_arg_float", libgtk4), Float32, (Ptr{GObject}, Ptr{GBytes}, Int32), instance, _args, _idx)
        ret
    end
    function get_arg_int(instance::GskGLShader, _args::GBytes, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_arg_int", libgtk4), Int32, (Ptr{GObject}, Ptr{GBytes}, Int32), instance, _args, _idx)
        ret
    end
    function get_arg_uint(instance::GskGLShader, _args::GBytes, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_arg_uint", libgtk4), UInt32, (Ptr{GObject}, Ptr{GBytes}, Int32), instance, _args, _idx)
        ret
    end
    function get_arg_vec2(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::Union{GrapheneVec2, Ref{_GrapheneVec2}})
        ret = ccall(("gsk_gl_shader_get_arg_vec2", libgtk4), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{_GrapheneVec2}), instance, _args, _idx, _out_value)
        nothing
    end
    function get_arg_vec3(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::Union{GrapheneVec3, Ref{_GrapheneVec3}})
        ret = ccall(("gsk_gl_shader_get_arg_vec3", libgtk4), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{_GrapheneVec3}), instance, _args, _idx, _out_value)
        nothing
    end
    function get_arg_vec4(instance::GskGLShader, _args::GBytes, _idx::Integer, _out_value::Union{GrapheneVec4, Ref{_GrapheneVec4}})
        ret = ccall(("gsk_gl_shader_get_arg_vec4", libgtk4), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{_GrapheneVec4}), instance, _args, _idx, _out_value)
        nothing
    end
    function get_args_size(instance::GskGLShader)
        ret = ccall(("gsk_gl_shader_get_args_size", libgtk4), UInt64, (Ptr{GObject},), instance)
        ret
    end
    function get_n_textures(instance::GskGLShader)
        ret = ccall(("gsk_gl_shader_get_n_textures", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_n_uniforms(instance::GskGLShader)
        ret = ccall(("gsk_gl_shader_get_n_uniforms", libgtk4), Int32, (Ptr{GObject},), instance)
        ret
    end
    function get_resource(instance::GskGLShader)
        ret = ccall(("gsk_gl_shader_get_resource", libgtk4), Cstring, (Ptr{GObject},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_source(instance::GskGLShader)
        ret = ccall(("gsk_gl_shader_get_source", libgtk4), Ptr{GBytes}, (Ptr{GObject},), instance)
        ret2 = convert(GBytes, ret, false)
        ret2
    end
    function get_uniform_name(instance::GskGLShader, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_uniform_name", libgtk4), Cstring, (Ptr{GObject}, Int32), instance, _idx)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_uniform_offset(instance::GskGLShader, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_uniform_offset", libgtk4), Int32, (Ptr{GObject}, Int32), instance, _idx)
        ret
    end
    function get_uniform_type(instance::GskGLShader, _idx::Integer)
        ret = ccall(("gsk_gl_shader_get_uniform_type", libgtk4), UInt32, (Ptr{GObject}, Int32), instance, _idx)
        ret2 = GLUniformType(ret)
        ret2
    end
    function GLShaderNode_new(_shader::GskGLShader, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _args::GBytes, _children)
        _children = convert(Vector{Ptr{GskRenderNode}}, _children)
        _n_children = length(_children)
        ret = ccall(("gsk_gl_shader_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_GrapheneRect}, Ptr{GBytes}, Ptr{Ptr{GskRenderNode}}, UInt32), _shader, _bounds, _args, _children, _n_children)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_args(instance::GskGLShaderNode)
        ret = ccall(("gsk_gl_shader_node_get_args", libgtk4), Ptr{GBytes}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GBytes, ret, false)
        ret2
    end
    function get_child(instance::GskGLShaderNode, _idx::Integer)
        ret = ccall(("gsk_gl_shader_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, UInt32), instance, _idx)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_n_children(instance::GskGLShaderNode)
        ret = ccall(("gsk_gl_shader_node_get_n_children", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_shader(instance::GskGLShaderNode)
        ret = ccall(("gsk_gl_shader_node_get_shader", libgtk4), Ptr{GObject}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskGLShader, ret, false)
        ret2
    end
    function InsetShadowNode_new(_outline::_GskRoundedRect, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real)
        ret = ccall(("gsk_inset_shadow_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{_GdkRGBA}, Float32, Float32, Float32, Float32), _outline, _color, _dx, _dy, _spread, _blur_radius)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_blur_radius(instance::GskInsetShadowNode)
        ret = ccall(("gsk_inset_shadow_node_get_blur_radius", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_color(instance::GskInsetShadowNode)
        ret = ccall(("gsk_inset_shadow_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false)
        ret2
    end
    function get_dx(instance::GskInsetShadowNode)
        ret = ccall(("gsk_inset_shadow_node_get_dx", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_dy(instance::GskInsetShadowNode)
        ret = ccall(("gsk_inset_shadow_node_get_dy", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_outline(instance::GskInsetShadowNode)
        ret = ccall(("gsk_inset_shadow_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function get_spread(instance::GskInsetShadowNode)
        ret = ccall(("gsk_inset_shadow_node_get_spread", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function LinearGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start::Union{GraphenePoint, Ref{_GraphenePoint}}, _end::Union{GraphenePoint, Ref{_GraphenePoint}}, _color_stops)
        _color_stops = convert(Vector{_GskColorStop}, _color_stops)
        _n_color_stops = length(_color_stops)
        ret = ccall(("gsk_linear_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GskColorStop}, UInt64), _bounds, _start, _end, _color_stops, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_color_stops(instance::GskLinearGradientNode)
        m_n_stops = Ref{UInt64}()
        ret = ccall(("gsk_linear_gradient_node_get_color_stops", libgtk4), Ptr{_GskColorStop}, (Ptr{GskRenderNode}, Ptr{UInt64}), instance, m_n_stops)
        _n_stops = m_n_stops[]
        ret
    end
    function get_end(instance::GskLinearGradientNode)
        ret = ccall(("gsk_linear_gradient_node_get_end", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false)
        ret2
    end
    function get_n_color_stops(instance::GskLinearGradientNode)
        ret = ccall(("gsk_linear_gradient_node_get_n_color_stops", libgtk4), UInt64, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_start(instance::GskLinearGradientNode)
        ret = ccall(("gsk_linear_gradient_node_get_start", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false)
        ret2
    end
    function OpacityNode_new(_child::GskRenderNode, _opacity::Real)
        ret = ccall(("gsk_opacity_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Float32), _child, _opacity)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskOpacityNode)
        ret = ccall(("gsk_opacity_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_opacity(instance::GskOpacityNode)
        ret = ccall(("gsk_opacity_node_get_opacity", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function OutsetShadowNode_new(_outline::_GskRoundedRect, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _dx::Real, _dy::Real, _spread::Real, _blur_radius::Real)
        ret = ccall(("gsk_outset_shadow_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{_GdkRGBA}, Float32, Float32, Float32, Float32), _outline, _color, _dx, _dy, _spread, _blur_radius)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_blur_radius(instance::GskOutsetShadowNode)
        ret = ccall(("gsk_outset_shadow_node_get_blur_radius", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_color(instance::GskOutsetShadowNode)
        ret = ccall(("gsk_outset_shadow_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false)
        ret2
    end
    function get_dx(instance::GskOutsetShadowNode)
        ret = ccall(("gsk_outset_shadow_node_get_dx", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_dy(instance::GskOutsetShadowNode)
        ret = ccall(("gsk_outset_shadow_node_get_dy", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_outline(instance::GskOutsetShadowNode)
        ret = ccall(("gsk_outset_shadow_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function get_spread(instance::GskOutsetShadowNode)
        ret = ccall(("gsk_outset_shadow_node_get_spread", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function RadialGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops)
        _color_stops = convert(Vector{_GskColorStop}, _color_stops)
        _n_color_stops = length(_color_stops)
        ret = ccall(("gsk_radial_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Float32, Float32, Float32, Ptr{_GskColorStop}, UInt64), _bounds, _center, _hradius, _vradius, _start, _end, _color_stops, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_center(instance::GskRadialGradientNode)
        ret = ccall(("gsk_radial_gradient_node_get_center", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false)
        ret2
    end
    function get_color_stops(instance::GskRadialGradientNode)
        m_n_stops = Ref{UInt64}()
        ret = ccall(("gsk_radial_gradient_node_get_color_stops", libgtk4), Ptr{_GskColorStop}, (Ptr{GskRenderNode}, Ptr{UInt64}), instance, m_n_stops)
        _n_stops = m_n_stops[]
        ret
    end
    function get_end(instance::GskRadialGradientNode)
        ret = ccall(("gsk_radial_gradient_node_get_end", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_hradius(instance::GskRadialGradientNode)
        ret = ccall(("gsk_radial_gradient_node_get_hradius", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_n_color_stops(instance::GskRadialGradientNode)
        ret = ccall(("gsk_radial_gradient_node_get_n_color_stops", libgtk4), UInt64, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_start(instance::GskRadialGradientNode)
        ret = ccall(("gsk_radial_gradient_node_get_start", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_vradius(instance::GskRadialGradientNode)
        ret = ccall(("gsk_radial_gradient_node_get_vradius", libgtk4), Float32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function deserialize(_bytes::GBytes, _error_func::Maybe(Function), _user_data::Maybe(Nothing))
        _error_func = nothing_to_null(_error_func)
        _user_data = nothing_to_null(_user_data)
        ret = ccall(("gsk_render_node_deserialize", libgtk4), Ptr{GskRenderNode}, (Ptr{GBytes}, Ptr{Nothing}, Ptr{Nothing}), _bytes, _error_func, _user_data)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function draw(instance::GskRenderNode, _cr::cairoContext)
        ret = ccall(("gsk_render_node_draw", libgtk4), Nothing, (Ptr{GskRenderNode}, Ptr{cairoContext}), instance, _cr)
        nothing
    end
    function get_bounds(instance::GskRenderNode)
        m_bounds = Ref{_GrapheneRect}()
        ret = ccall(("gsk_render_node_get_bounds", libgtk4), Nothing, (Ptr{GskRenderNode}, Ptr{_GrapheneRect}), instance, m_bounds)
        _bounds = m_bounds[]
        _bounds
    end
    function get_node_type(instance::GskRenderNode)
        ret = ccall(("gsk_render_node_get_node_type", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret2 = RenderNodeType(ret)
        ret2
    end
    function ref(instance::GskRenderNode)
        ret = ccall(("gsk_render_node_ref", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function serialize(instance::GskRenderNode)
        ret = ccall(("gsk_render_node_serialize", libgtk4), Ptr{GBytes}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function unref(instance::GskRenderNode)
        ret = ccall(("gsk_render_node_unref", libgtk4), Nothing, (Ptr{GskRenderNode},), instance)
        nothing
    end
    function write_to_file(instance::GskRenderNode, _filename::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("gsk_render_node_write_to_file", libgtk4), Cint, (Ptr{GskRenderNode}, Cstring, Ptr{Ptr{GError}}), instance, _filename, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function Renderer_new_for_surface(_surface::GdkSurface)
        ret = ccall(("gsk_renderer_new_for_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), _surface)
        ret2 = convert_if_not_null(GskRenderer, ret, true)
        ret2
    end
    function get_surface(instance::GskRenderer)
        ret = ccall(("gsk_renderer_get_surface", libgtk4), Ptr{GObject}, (Ptr{GObject},), instance)
        ret2 = convert_if_not_null(GdkSurface, ret, false)
        ret2
    end
    function is_realized(instance::GskRenderer)
        ret = ccall(("gsk_renderer_is_realized", libgtk4), Cint, (Ptr{GObject},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function realize(instance::GskRenderer, _surface::Maybe(GdkSurface))
        _surface = nothing_to_null(_surface)
        err = err_buf()
        ret = ccall(("gsk_renderer_realize", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _surface, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function render(instance::GskRenderer, _root::GskRenderNode, _region::Maybe(cairoRegion))
        _region = nothing_to_null(_region)
        ret = ccall(("gsk_renderer_render", libgtk4), Nothing, (Ptr{GObject}, Ptr{GskRenderNode}, Ptr{cairoRegion}), instance, _root, _region)
        nothing
    end
    function render_texture(instance::GskRenderer, _root::GskRenderNode, _viewport::Maybe(Union{GrapheneRect, Ref{_GrapheneRect}}))
        _viewport = nothing_to_null(_viewport)
        ret = ccall(("gsk_renderer_render_texture", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GskRenderNode}, Ptr{_GrapheneRect}), instance, _root, _viewport)
        ret2 = convert(GdkTexture, ret, true)
        ret2
    end
    function unrealize(instance::GskRenderer)
        ret = ccall(("gsk_renderer_unrealize", libgtk4), Nothing, (Ptr{GObject},), instance)
        nothing
    end
    function RepeatNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _child::GskRenderNode, _child_bounds::Maybe(Union{GrapheneRect, Ref{_GrapheneRect}}))
        _child_bounds = nothing_to_null(_child_bounds)
        ret = ccall(("gsk_repeat_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{GskRenderNode}, Ptr{_GrapheneRect}), _bounds, _child, _child_bounds)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskRepeatNode)
        ret = ccall(("gsk_repeat_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child_bounds(instance::GskRepeatNode)
        ret = ccall(("gsk_repeat_node_get_child_bounds", libgtk4), Ptr{_GrapheneRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GrapheneRect, Ref{_GrapheneRect}}, ret, false)
        ret2
    end
    function RepeatingLinearGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _start::Union{GraphenePoint, Ref{_GraphenePoint}}, _end::Union{GraphenePoint, Ref{_GraphenePoint}}, _color_stops)
        _color_stops = convert(Vector{_GskColorStop}, _color_stops)
        _n_color_stops = length(_color_stops)
        ret = ccall(("gsk_repeating_linear_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Ptr{_GraphenePoint}, Ptr{_GskColorStop}, UInt64), _bounds, _start, _end, _color_stops, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function RepeatingRadialGradientNode_new(_bounds::Union{GrapheneRect, Ref{_GrapheneRect}}, _center::Union{GraphenePoint, Ref{_GraphenePoint}}, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops)
        _color_stops = convert(Vector{_GskColorStop}, _color_stops)
        _n_color_stops = length(_color_stops)
        ret = ccall(("gsk_repeating_radial_gradient_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{_GraphenePoint}, Float32, Float32, Float32, Float32, Ptr{_GskColorStop}, UInt64), _bounds, _center, _hradius, _vradius, _start, _end, _color_stops, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function RoundedClipNode_new(_child::GskRenderNode, _clip::_GskRoundedRect)
        ret = ccall(("gsk_rounded_clip_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GskRoundedRect}), _child, _clip)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskRoundedClipNode)
        ret = ccall(("gsk_rounded_clip_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_clip(instance::GskRoundedClipNode)
        ret = ccall(("gsk_rounded_clip_node_get_clip", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(_GskRoundedRect, ret)
        ret2
    end
    function ShadowNode_new(_child::GskRenderNode, _shadows)
        _shadows = convert(Vector{_GskShadow}, _shadows)
        _n_shadows = length(_shadows)
        ret = ccall(("gsk_shadow_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GskShadow}, UInt64), _child, _shadows, _n_shadows)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskShadowNode)
        ret = ccall(("gsk_shadow_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_n_shadows(instance::GskShadowNode)
        ret = ccall(("gsk_shadow_node_get_n_shadows", libgtk4), UInt64, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_shadow(instance::GskShadowNode, _i::Integer)
        ret = ccall(("gsk_shadow_node_get_shadow", libgtk4), Ptr{_GskShadow}, (Ptr{GskRenderNode}, UInt64), instance, _i)
        ret2 = convert(_GskShadow, ret)
        ret2
    end
    function TextNode_new(_font::PangoFont, _glyphs::Union{PangoGlyphString, Ref{_PangoGlyphString}}, _color::Union{GdkRGBA, Ref{_GdkRGBA}}, _offset::Union{GraphenePoint, Ref{_GraphenePoint}})
        ret = ccall(("gsk_text_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_PangoGlyphString}, Ptr{_GdkRGBA}, Ptr{_GraphenePoint}), _font, _glyphs, _color, _offset)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_color(instance::GskTextNode)
        ret = ccall(("gsk_text_node_get_color", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GdkRGBA, Ref{_GdkRGBA}}, ret, false)
        ret2
    end
    function get_font(instance::GskTextNode)
        ret = ccall(("gsk_text_node_get_font", libgtk4), Ptr{GObject}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(PangoFont, ret, false)
        ret2
    end
    function get_glyphs(instance::GskTextNode)
        m_n_glyphs = Ref{UInt32}()
        ret = ccall(("gsk_text_node_get_glyphs", libgtk4), Ptr{_PangoGlyphInfo}, (Ptr{GskRenderNode}, Ptr{UInt32}), instance, m_n_glyphs)
        _n_glyphs = m_n_glyphs[]
        ret
    end
    function get_num_glyphs(instance::GskTextNode)
        ret = ccall(("gsk_text_node_get_num_glyphs", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_offset(instance::GskTextNode)
        ret = ccall(("gsk_text_node_get_offset", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Union{GraphenePoint, Ref{_GraphenePoint}}, ret, false)
        ret2
    end
    function has_color_glyphs(instance::GskTextNode)
        ret = ccall(("gsk_text_node_has_color_glyphs", libgtk4), Cint, (Ptr{GskRenderNode},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function TextureNode_new(_texture::GdkTexture, _bounds::Union{GrapheneRect, Ref{_GrapheneRect}})
        ret = ccall(("gsk_texture_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_GrapheneRect}), _texture, _bounds)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_texture(instance::GskTextureNode)
        ret = ccall(("gsk_texture_node_get_texture", libgtk4), Ptr{GObject}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GdkTexture, ret, false)
        ret2
    end
    function TransformNode_new(_child::GskRenderNode, _transform::GskTransform)
        ret = ccall(("gsk_transform_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{GskTransform}), _child, _transform)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_child(instance::GskTransformNode)
        ret = ccall(("gsk_transform_node_get_child", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_transform(instance::GskTransformNode)
        ret = ccall(("gsk_transform_node_get_transform", libgtk4), Ptr{GskTransform}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskTransform, ret, false)
        ret2
    end
end))
end
