begin
    function get_bounds(instance::GskPath)
        m_bounds = Ref{_GrapheneRect}()
        ret = ccall(("gsk_path_get_bounds", libgtk4), Cint, (Ptr{GskPath}, Ptr{_GrapheneRect}), instance, m_bounds)
        ret2 = convert(Bool, ret)
        _bounds = m_bounds[]
        (ret2, _bounds)
    end
    function get_closest_point(instance::GskPath, _point::GraphenePointLike, _threshold::Real)
        m_result = Ref{GskPathPoint}()
        m_distance = Ref{Float32}()
        ret = ccall(("gsk_path_get_closest_point", libgtk4), Cint, (Ptr{GskPath}, Ptr{_GraphenePoint}, Float32, Ptr{GskPathPoint}, Ptr{Float32}), instance, _point, _threshold, m_result, m_distance)
        ret2 = convert(Bool, ret)
        _result = m_result[]
        _distance = m_distance[]
        (ret2, _result, _distance)
    end
    function get_end_point(instance::GskPath)
        m_result = Ref{GskPathPoint}()
        ret = ccall(("gsk_path_get_end_point", libgtk4), Cint, (Ptr{GskPath}, Ptr{GskPathPoint}), instance, m_result)
        ret2 = convert(Bool, ret)
        _result = m_result[]
        (ret2, _result)
    end
    function get_start_point(instance::GskPath)
        m_result = Ref{GskPathPoint}()
        ret = ccall(("gsk_path_get_start_point", libgtk4), Cint, (Ptr{GskPath}, Ptr{GskPathPoint}), instance, m_result)
        ret2 = convert(Bool, ret)
        _result = m_result[]
        (ret2, _result)
    end
    function get_stroke_bounds(instance::GskPath, _stroke::GskStroke)
        m_bounds = Ref{_GrapheneRect}()
        ret = ccall(("gsk_path_get_stroke_bounds", libgtk4), Cint, (Ptr{GskPath}, Ptr{GskStroke}, Ptr{_GrapheneRect}), instance, _stroke, m_bounds)
        ret2 = convert(Bool, ret)
        _bounds = m_bounds[]
        (ret2, _bounds)
    end
    function in_fill(instance::GskPath, _point::GraphenePointLike, _fill_rule)
        ret = ccall(("gsk_path_in_fill", libgtk4), Cint, (Ptr{GskPath}, Ptr{_GraphenePoint}, UInt32), instance, _point, _fill_rule)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_closed(instance::GskPath)
        ret = ccall(("gsk_path_is_closed", libgtk4), Cint, (Ptr{GskPath},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_empty(instance::GskPath)
        ret = ccall(("gsk_path_is_empty", libgtk4), Cint, (Ptr{GskPath},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function print(instance::GskPath, _string::GStringLike)
        ret = ccall(("gsk_path_print", libgtk4), Nothing, (Ptr{GskPath}, Ptr{_GString}), instance, _string)
        nothing
    end
    function ref(instance::GskPath)
        ret = ccall(("gsk_path_ref", libgtk4), Ptr{GskPath}, (Ptr{GskPath},), instance)
        ret2 = convert(GskPath, ret, true)
        ret2
    end
    function to_cairo(instance::GskPath, _cr::cairoContext)
        ret = ccall(("gsk_path_to_cairo", libgtk4), Nothing, (Ptr{GskPath}, Ptr{cairoContext}), instance, _cr)
        nothing
    end
    function to_string(instance::GskPath)
        ret = ccall(("gsk_path_to_string", libgtk4), Cstring, (Ptr{GskPath},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function unref(instance::GskPath)
        ret = ccall(("gsk_path_unref", libgtk4), Nothing, (Ptr{GskPath},), instance)
        nothing
    end
    function PathBuilder_new()
        ret = ccall(("gsk_path_builder_new", libgtk4), Ptr{GskPathBuilder}, ())
        ret2 = convert(GskPathBuilder, ret, true)
        ret2
    end
    function add_cairo_path(instance::GskPathBuilder, _path::cairoPath)
        ret = ccall(("gsk_path_builder_add_cairo_path", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{cairoPath}), instance, _path)
        nothing
    end
    function add_circle(instance::GskPathBuilder, _center::GraphenePointLike, _radius::Real)
        ret = ccall(("gsk_path_builder_add_circle", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{_GraphenePoint}, Float32), instance, _center, _radius)
        nothing
    end
    function add_layout(instance::GskPathBuilder, _layout::PangoLayout)
        ret = ccall(("gsk_path_builder_add_layout", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{GObject}), instance, _layout)
        nothing
    end
    function add_path(instance::GskPathBuilder, _path::GskPath)
        ret = ccall(("gsk_path_builder_add_path", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{GskPath}), instance, _path)
        nothing
    end
    function add_rect(instance::GskPathBuilder, _rect::GrapheneRectLike)
        ret = ccall(("gsk_path_builder_add_rect", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{_GrapheneRect}), instance, _rect)
        nothing
    end
    function add_reverse_path(instance::GskPathBuilder, _path::GskPath)
        ret = ccall(("gsk_path_builder_add_reverse_path", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{GskPath}), instance, _path)
        nothing
    end
    function add_rounded_rect(instance::GskPathBuilder, _rect::GskRoundedRectLike)
        ret = ccall(("gsk_path_builder_add_rounded_rect", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{_GskRoundedRect}), instance, _rect)
        nothing
    end
    function add_segment(instance::GskPathBuilder, _path::GskPath, _start::GskPathPoint, _end::GskPathPoint)
        ret = ccall(("gsk_path_builder_add_segment", libgtk4), Nothing, (Ptr{GskPathBuilder}, Ptr{GskPath}, Ptr{GskPathPoint}, Ptr{GskPathPoint}), instance, _path, _start, _end)
        nothing
    end
    function arc_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real)
        ret = ccall(("gsk_path_builder_arc_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2)
        nothing
    end
    function close(instance::GskPathBuilder)
        ret = ccall(("gsk_path_builder_close", libgtk4), Nothing, (Ptr{GskPathBuilder},), instance)
        nothing
    end
    function conic_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real, _weight::Real)
        ret = ccall(("gsk_path_builder_conic_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2, _weight)
        nothing
    end
    function cubic_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real, _x3::Real, _y3::Real)
        ret = ccall(("gsk_path_builder_cubic_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2, _x3, _y3)
        nothing
    end
    function get_current_point(instance::GskPathBuilder)
        ret = ccall(("gsk_path_builder_get_current_point", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskPathBuilder},), instance)
        ret2 = convert(GraphenePointLike, ret, false)
        ret2
    end
    function html_arc_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real, _radius::Real)
        ret = ccall(("gsk_path_builder_html_arc_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2, _radius)
        nothing
    end
    function line_to(instance::GskPathBuilder, _x::Real, _y::Real)
        ret = ccall(("gsk_path_builder_line_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32), instance, _x, _y)
        nothing
    end
    function move_to(instance::GskPathBuilder, _x::Real, _y::Real)
        ret = ccall(("gsk_path_builder_move_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32), instance, _x, _y)
        nothing
    end
    function quad_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real)
        ret = ccall(("gsk_path_builder_quad_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2)
        nothing
    end
    function ref(instance::GskPathBuilder)
        ret = ccall(("gsk_path_builder_ref", libgtk4), Ptr{GskPathBuilder}, (Ptr{GskPathBuilder},), instance)
        ret2 = convert(GskPathBuilder, ret, false)
        ret2
    end
    function rel_arc_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real)
        ret = ccall(("gsk_path_builder_rel_arc_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2)
        nothing
    end
    function rel_conic_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real, _weight::Real)
        ret = ccall(("gsk_path_builder_rel_conic_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2, _weight)
        nothing
    end
    function rel_cubic_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real, _x3::Real, _y3::Real)
        ret = ccall(("gsk_path_builder_rel_cubic_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2, _x3, _y3)
        nothing
    end
    function rel_html_arc_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real, _radius::Real)
        ret = ccall(("gsk_path_builder_rel_html_arc_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2, _radius)
        nothing
    end
    function rel_line_to(instance::GskPathBuilder, _x::Real, _y::Real)
        ret = ccall(("gsk_path_builder_rel_line_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32), instance, _x, _y)
        nothing
    end
    function rel_move_to(instance::GskPathBuilder, _x::Real, _y::Real)
        ret = ccall(("gsk_path_builder_rel_move_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32), instance, _x, _y)
        nothing
    end
    function rel_quad_to(instance::GskPathBuilder, _x1::Real, _y1::Real, _x2::Real, _y2::Real)
        ret = ccall(("gsk_path_builder_rel_quad_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Float32), instance, _x1, _y1, _x2, _y2)
        nothing
    end
    function rel_svg_arc_to(instance::GskPathBuilder, _rx::Real, _ry::Real, _x_axis_rotation::Real, _large_arc::Bool, _positive_sweep::Bool, _x::Real, _y::Real)
        ret = ccall(("gsk_path_builder_rel_svg_arc_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Cint, Cint, Float32, Float32), instance, _rx, _ry, _x_axis_rotation, _large_arc, _positive_sweep, _x, _y)
        nothing
    end
    function svg_arc_to(instance::GskPathBuilder, _rx::Real, _ry::Real, _x_axis_rotation::Real, _large_arc::Bool, _positive_sweep::Bool, _x::Real, _y::Real)
        ret = ccall(("gsk_path_builder_svg_arc_to", libgtk4), Nothing, (Ptr{GskPathBuilder}, Float32, Float32, Float32, Cint, Cint, Float32, Float32), instance, _rx, _ry, _x_axis_rotation, _large_arc, _positive_sweep, _x, _y)
        nothing
    end
    function to_path(instance::GskPathBuilder)
        ret = ccall(("gsk_path_builder_to_path", libgtk4), Ptr{GskPath}, (Ptr{GskPathBuilder},), instance)
        ret2 = convert(GskPath, ret, true)
        ret2
    end
    function unref(instance::GskPathBuilder)
        ret = ccall(("gsk_path_builder_unref", libgtk4), Nothing, (Ptr{GskPathBuilder},), instance)
        nothing
    end
    function PathMeasure_new(_path::GskPath)
        ret = ccall(("gsk_path_measure_new", libgtk4), Ptr{GskPathMeasure}, (Ptr{GskPath},), _path)
        ret2 = convert(GskPathMeasure, ret, true)
        ret2
    end
    function PathMeasure_new_with_tolerance(_path::GskPath, _tolerance::Real)
        ret = ccall(("gsk_path_measure_new_with_tolerance", libgtk4), Ptr{GskPathMeasure}, (Ptr{GskPath}, Float32), _path, _tolerance)
        ret2 = convert(GskPathMeasure, ret, true)
        ret2
    end
    function get_length(instance::GskPathMeasure)
        ret = ccall(("gsk_path_measure_get_length", libgtk4), Float32, (Ptr{GskPathMeasure},), instance)
        ret
    end
    function get_path(instance::GskPathMeasure)
        ret = ccall(("gsk_path_measure_get_path", libgtk4), Ptr{GskPath}, (Ptr{GskPathMeasure},), instance)
        ret2 = convert(GskPath, ret, false)
        ret2
    end
    function get_point(instance::GskPathMeasure, _distance::Real)
        m_result = Ref{GskPathPoint}()
        ret = ccall(("gsk_path_measure_get_point", libgtk4), Cint, (Ptr{GskPathMeasure}, Float32, Ptr{GskPathPoint}), instance, _distance, m_result)
        ret2 = convert(Bool, ret)
        _result = m_result[]
        (ret2, _result)
    end
    function get_tolerance(instance::GskPathMeasure)
        ret = ccall(("gsk_path_measure_get_tolerance", libgtk4), Float32, (Ptr{GskPathMeasure},), instance)
        ret
    end
    function ref(instance::GskPathMeasure)
        ret = ccall(("gsk_path_measure_ref", libgtk4), Ptr{GskPathMeasure}, (Ptr{GskPathMeasure},), instance)
        ret2 = convert(GskPathMeasure, ret, true)
        ret2
    end
    function unref(instance::GskPathMeasure)
        ret = ccall(("gsk_path_measure_unref", libgtk4), Nothing, (Ptr{GskPathMeasure},), instance)
        nothing
    end
    function compare(instance::GskPathPoint, _point2::GskPathPoint)
        ret = ccall(("gsk_path_point_compare", libgtk4), Int32, (Ptr{GskPathPoint}, Ptr{GskPathPoint}), instance, _point2)
        ret
    end
    function copy(instance::GskPathPoint)
        ret = ccall(("gsk_path_point_copy", libgtk4), Ptr{GskPathPoint}, (Ptr{GskPathPoint},), instance)
        ret2 = convert(GskPathPoint, ret, true)
        ret2
    end
    function equal(instance::GskPathPoint, _point2::GskPathPoint)
        ret = ccall(("gsk_path_point_equal", libgtk4), Cint, (Ptr{GskPathPoint}, Ptr{GskPathPoint}), instance, _point2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function free(instance::GskPathPoint)
        ret = ccall(("gsk_path_point_free", libgtk4), Nothing, (Ptr{GskPathPoint},), instance)
        nothing
    end
    function get_curvature(instance::GskPathPoint, _path::GskPath, _direction)
        m_center = Ref{_GraphenePoint}()
        ret = ccall(("gsk_path_point_get_curvature", libgtk4), Float32, (Ptr{GskPathPoint}, Ptr{GskPath}, UInt32, Ptr{_GraphenePoint}), instance, _path, _direction, m_center)
        _center = m_center[]
        _center = convert_if_not_null(GraphenePointLike, _center, false)
        (ret, _center)
    end
    function get_distance(instance::GskPathPoint, _measure::GskPathMeasure)
        ret = ccall(("gsk_path_point_get_distance", libgtk4), Float32, (Ptr{GskPathPoint}, Ptr{GskPathMeasure}), instance, _measure)
        ret
    end
    function get_position(instance::GskPathPoint, _path::GskPath)
        m_position = Ref{_GraphenePoint}()
        ret = ccall(("gsk_path_point_get_position", libgtk4), Nothing, (Ptr{GskPathPoint}, Ptr{GskPath}, Ptr{_GraphenePoint}), instance, _path, m_position)
        _position = m_position[]
        _position
    end
    function get_rotation(instance::GskPathPoint, _path::GskPath, _direction)
        ret = ccall(("gsk_path_point_get_rotation", libgtk4), Float32, (Ptr{GskPathPoint}, Ptr{GskPath}, UInt32), instance, _path, _direction)
        ret
    end
    function get_tangent(instance::GskPathPoint, _path::GskPath, _direction)
        m_tangent = Ref{_GrapheneVec2}()
        ret = ccall(("gsk_path_point_get_tangent", libgtk4), Nothing, (Ptr{GskPathPoint}, Ptr{GskPath}, UInt32, Ptr{_GrapheneVec2}), instance, _path, _direction, m_tangent)
        _tangent = m_tangent[]
        _tangent
    end
    function contains_point(instance::GskRoundedRectLike, _point::GraphenePointLike)
        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::GskRoundedRectLike, _rect::GrapheneRectLike)
        ret = ccall(("gsk_rounded_rect_contains_rect", libgtk4), Cint, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}), instance, _rect)
        ret2 = convert(Bool, ret)
        ret2
    end
    function init(instance::GskRoundedRectLike, _bounds::GrapheneRectLike, _top_left::GrapheneSizeLike, _top_right::GrapheneSizeLike, _bottom_right::GrapheneSizeLike, _bottom_left::GrapheneSizeLike)
        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(GskRoundedRectLike, ret)
        ret2
    end
    function init_copy(instance::GskRoundedRectLike, _src::GskRoundedRectLike)
        ret = ccall(("gsk_rounded_rect_init_copy", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GskRoundedRect}), instance, _src)
        ret2 = convert(GskRoundedRectLike, ret)
        ret2
    end
    function init_from_rect(instance::GskRoundedRectLike, _bounds::GrapheneRectLike, _radius::Real)
        ret = ccall(("gsk_rounded_rect_init_from_rect", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Ptr{_GrapheneRect}, Float32), instance, _bounds, _radius)
        ret2 = convert(GskRoundedRectLike, ret)
        ret2
    end
    function intersects_rect(instance::GskRoundedRectLike, _rect::GrapheneRectLike)
        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::GskRoundedRectLike)
        ret = ccall(("gsk_rounded_rect_is_rectilinear", libgtk4), Cint, (Ptr{_GskRoundedRect},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function normalize(instance::GskRoundedRectLike)
        ret = ccall(("gsk_rounded_rect_normalize", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect},), instance)
        ret2 = convert(GskRoundedRectLike, ret)
        ret2
    end
    function offset(instance::GskRoundedRectLike, _dx::Real, _dy::Real)
        ret = ccall(("gsk_rounded_rect_offset", libgtk4), Ptr{_GskRoundedRect}, (Ptr{_GskRoundedRect}, Float32, Float32), instance, _dx, _dy)
        ret2 = convert(GskRoundedRectLike, ret)
        ret2
    end
    function shrink(instance::GskRoundedRectLike, _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(GskRoundedRectLike, ret)
        ret2
    end
    function Stroke_new(_line_width::Real)
        ret = ccall(("gsk_stroke_new", libgtk4), Ptr{GskStroke}, (Float32,), _line_width)
        ret2 = convert(GskStroke, ret, true)
        ret2
    end
    function copy(instance::GskStroke)
        ret = ccall(("gsk_stroke_copy", libgtk4), Ptr{GskStroke}, (Ptr{GskStroke},), instance)
        ret2 = convert(GskStroke, ret, true)
        ret2
    end
    function free(instance::GskStroke)
        ret = ccall(("gsk_stroke_free", libgtk4), Nothing, (Ptr{GskStroke},), instance)
        nothing
    end
    function get_dash(instance::GskStroke)
        m_n_dash = Ref{UInt64}()
        ret = ccall(("gsk_stroke_get_dash", libgtk4), Ptr{Float32}, (Ptr{GskStroke}, Ptr{UInt64}), instance, m_n_dash)
        ret2 = collect(unsafe_wrap(Vector{Float32}, ret, m_n_dash[]))
        _n_dash = m_n_dash[]
        ret2
    end
    function get_dash_offset(instance::GskStroke)
        ret = ccall(("gsk_stroke_get_dash_offset", libgtk4), Float32, (Ptr{GskStroke},), instance)
        ret
    end
    function get_line_cap(instance::GskStroke)
        ret = ccall(("gsk_stroke_get_line_cap", libgtk4), UInt32, (Ptr{GskStroke},), instance)
        ret2 = LineCap(ret)
        ret2
    end
    function get_line_join(instance::GskStroke)
        ret = ccall(("gsk_stroke_get_line_join", libgtk4), UInt32, (Ptr{GskStroke},), instance)
        ret2 = LineJoin(ret)
        ret2
    end
    function get_line_width(instance::GskStroke)
        ret = ccall(("gsk_stroke_get_line_width", libgtk4), Float32, (Ptr{GskStroke},), instance)
        ret
    end
    function get_miter_limit(instance::GskStroke)
        ret = ccall(("gsk_stroke_get_miter_limit", libgtk4), Float32, (Ptr{GskStroke},), instance)
        ret
    end
    function set_dash(instance::GskStroke, _dash)
        _dash_arr = convert(Vector{Float32}, _dash)
        _n_dash = length(_dash)
        ret = ccall(("gsk_stroke_set_dash", libgtk4), Nothing, (Ptr{GskStroke}, Ptr{Float32}, UInt64), instance, _dash_arr, _n_dash)
        nothing
    end
    function set_dash_offset(instance::GskStroke, _offset::Real)
        ret = ccall(("gsk_stroke_set_dash_offset", libgtk4), Nothing, (Ptr{GskStroke}, Float32), instance, _offset)
        nothing
    end
    function set_line_cap(instance::GskStroke, _line_cap)
        ret = ccall(("gsk_stroke_set_line_cap", libgtk4), Nothing, (Ptr{GskStroke}, UInt32), instance, _line_cap)
        nothing
    end
    function set_line_join(instance::GskStroke, _line_join)
        ret = ccall(("gsk_stroke_set_line_join", libgtk4), Nothing, (Ptr{GskStroke}, UInt32), instance, _line_join)
        nothing
    end
    function set_line_width(instance::GskStroke, _line_width::Real)
        ret = ccall(("gsk_stroke_set_line_width", libgtk4), Nothing, (Ptr{GskStroke}, Float32), instance, _line_width)
        nothing
    end
    function set_miter_limit(instance::GskStroke, _limit::Real)
        ret = ccall(("gsk_stroke_set_miter_limit", libgtk4), Nothing, (Ptr{GskStroke}, Float32), instance, _limit)
        nothing
    end
    function to_cairo(instance::GskStroke, _cr::cairoContext)
        ret = ccall(("gsk_stroke_to_cairo", libgtk4), Nothing, (Ptr{GskStroke}, Ptr{cairoContext}), instance, _cr)
        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_maybe = nothing_to_null(_second)
        ret = ccall(("gsk_transform_equal", libgtk4), Cint, (Ptr{GskTransform}, Ptr{GskTransform}), instance, _second_maybe)
        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)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_invert", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform},), reffed_instance)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function matrix(instance::GskTransform, _matrix::GrapheneMatrixLike)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_matrix", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GrapheneMatrix}), reffed_instance, _matrix)
        ret2 = convert(GskTransform, ret, true)
        ret2
    end
    function perspective(instance::GskTransform, _depth::Real)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_perspective", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32), reffed_instance, _depth)
        ret2 = convert(GskTransform, ret, true)
        ret2
    end
    function print(instance::GskTransform, _string::GStringLike)
        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)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_rotate", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32), reffed_instance, _angle)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function rotate_3d(instance::GskTransform, _angle::Real, _axis::GrapheneVec3Like)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_rotate_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Ptr{_GrapheneVec3}), reffed_instance, _angle, _axis)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function scale(instance::GskTransform, _factor_x::Real, _factor_y::Real)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_scale", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Float32), reffed_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)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_scale_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Float32, Float32), reffed_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)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_skew", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Float32, Float32), reffed_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))
        reffed_instance = GLib.glib_ref(instance)
        _other_maybe = nothing_to_null(_other)
        ret = ccall(("gsk_transform_transform", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{GskTransform}), reffed_instance, _other_maybe)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function transform_bounds(instance::GskTransform, _rect::GrapheneRectLike)
        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::GraphenePointLike)
        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::GraphenePointLike)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_translate", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GraphenePoint}), reffed_instance, _point)
        ret2 = convert_if_not_null(GskTransform, ret, true)
        ret2
    end
    function translate_3d(instance::GskTransform, _point::GraphenePoint3DLike)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_transform_translate_3d", libgtk4), Ptr{GskTransform}, (Ptr{GskTransform}, Ptr{_GraphenePoint3D}), reffed_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::GskRoundedRectLike, _border_width, _border_color)
        _border_width_arr = convert(Vector{Float32}, _border_width)
        _border_color_arr = convert(Vector{_GdkRGBA}, _border_color)
        ret = ccall(("gsk_border_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GskRoundedRect}, Ptr{Float32}, Ptr{_GdkRGBA}), _outline, _border_width_arr, _border_color_arr)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_colors(instance::GskBorderNode)
        ret = ccall(("gsk_border_node_get_colors", libgtk4), Ptr{_GdkRGBA}, (Ptr{GskRenderNode},), instance)
        ret
    end
    function get_outline(instance::GskBorderNode)
        ret = ccall(("gsk_border_node_get_outline", libgtk4), Ptr{_GskRoundedRect}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRoundedRectLike, 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 = GskBroadwayRendererLeaf(ret, true)
        ret2
    end
    function CairoNode_new(_bounds::GrapheneRectLike)
        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 = GskCairoRendererLeaf(ret, true)
        ret2
    end
    function ClipNode_new(_child::GskRenderNode, _clip::GrapheneRectLike)
        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(GrapheneRectLike, ret, false)
        ret2
    end
    function ColorMatrixNode_new(_child::GskRenderNode, _color_matrix::GrapheneMatrixLike, _color_offset::GrapheneVec4Like)
        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(GrapheneMatrixLike, 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(GrapheneVec4Like, ret, false)
        ret2
    end
    function ColorNode_new(_rgba::GdkRGBALike, _bounds::GrapheneRectLike)
        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(GdkRGBALike, ret, false)
        ret2
    end
    function ConicGradientNode_new(_bounds::GrapheneRectLike, _center::GraphenePointLike, _rotation::Real, _color_stops)
        _color_stops_arr = 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_arr, _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(GraphenePointLike, 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)
        ret2 = collect(unsafe_wrap(Vector{_GskColorStop}, ret, m_n_stops[]))
        _n_stops = m_n_stops[]
        ret2
    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_arr = convert(Vector{Ptr{GskRenderNode}}, _children)
        _n_children = length(_children)
        ret = ccall(("gsk_container_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{Ptr{GskRenderNode}}, UInt32), _children_arr, _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 = GskGLRendererLeaf(ret, true)
        ret2
    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::GskRoundedRectLike, _color::GdkRGBALike, _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(GdkRGBALike, 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(GskRoundedRectLike, 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::GrapheneRectLike, _start::GraphenePointLike, _end::GraphenePointLike, _color_stops)
        _color_stops_arr = 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_arr, _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)
        ret2 = collect(unsafe_wrap(Vector{_GskColorStop}, ret, m_n_stops[]))
        _n_stops = m_n_stops[]
        ret2
    end
    function get_end(instance::GskLinearGradientNode)
        ret = ccall(("gsk_linear_gradient_node_get_end", libgtk4), Ptr{_GraphenePoint}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GraphenePointLike, 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(GraphenePointLike, ret, false)
        ret2
    end
    function MaskNode_new(_source::GskRenderNode, _mask::GskRenderNode, _mask_mode)
        ret = ccall(("gsk_mask_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{GskRenderNode}, UInt32), _source, _mask, _mask_mode)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_mask(instance::GskMaskNode)
        ret = ccall(("gsk_mask_node_get_mask", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_mask_mode(instance::GskMaskNode)
        ret = ccall(("gsk_mask_node_get_mask_mode", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret2 = MaskMode(ret)
        ret2
    end
    function get_source(instance::GskMaskNode)
        ret = ccall(("gsk_mask_node_get_source", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode},), instance)
        ret2 = convert(GskRenderNode, ret)
        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::GskRoundedRectLike, _color::GdkRGBALike, _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(GdkRGBALike, 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(GskRoundedRectLike, 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::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops)
        _color_stops_arr = 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_arr, _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(GraphenePointLike, 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)
        ret2 = collect(unsafe_wrap(Vector{_GskColorStop}, ret, m_n_stops[]))
        _n_stops = m_n_stops[]
        ret2
    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 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 get_opaque_rect(instance::GskRenderNode)
        m_out_opaque = Ref{_GrapheneRect}()
        ret = ccall(("gsk_render_node_get_opaque_rect", libgtk4), Cint, (Ptr{GskRenderNode}, Ptr{_GrapheneRect}), instance, m_out_opaque)
        ret2 = convert(Bool, ret)
        _out_opaque = m_out_opaque[]
        (ret2, _out_opaque)
    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)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("gsk_render_node_unref", libgtk4), Nothing, (Ptr{GskRenderNode},), reffed_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_maybe = nothing_to_null(_surface)
        err = err_buf()
        ret = ccall(("gsk_renderer_realize", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _surface_maybe, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function realize_for_display(instance::GskRenderer, _display::GdkDisplay)
        err = err_buf()
        ret = ccall(("gsk_renderer_realize_for_display", libgtk4), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _display, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function render(instance::GskRenderer, _root::GskRenderNode, _region::Maybe(cairoRegion))
        _region_maybe = nothing_to_null(_region)
        ret = ccall(("gsk_renderer_render", libgtk4), Nothing, (Ptr{GObject}, Ptr{GskRenderNode}, Ptr{cairoRegion}), instance, _root, _region_maybe)
        nothing
    end
    function render_texture(instance::GskRenderer, _root::GskRenderNode, _viewport::Maybe(GrapheneRectLike))
        _viewport_maybe = nothing_to_null(_viewport)
        ret = ccall(("gsk_renderer_render_texture", libgtk4), Ptr{GObject}, (Ptr{GObject}, Ptr{GskRenderNode}, Ptr{_GrapheneRect}), instance, _root, _viewport_maybe)
        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::GrapheneRectLike, _child::GskRenderNode, _child_bounds::Maybe(GrapheneRectLike))
        _child_bounds_maybe = nothing_to_null(_child_bounds)
        ret = ccall(("gsk_repeat_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{_GrapheneRect}, Ptr{GskRenderNode}, Ptr{_GrapheneRect}), _bounds, _child, _child_bounds_maybe)
        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(GrapheneRectLike, ret, false)
        ret2
    end
    function RepeatingLinearGradientNode_new(_bounds::GrapheneRectLike, _start::GraphenePointLike, _end::GraphenePointLike, _color_stops)
        _color_stops_arr = 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_arr, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function RepeatingRadialGradientNode_new(_bounds::GrapheneRectLike, _center::GraphenePointLike, _hradius::Real, _vradius::Real, _start::Real, _end::Real, _color_stops)
        _color_stops_arr = 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_arr, _n_color_stops)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function RoundedClipNode_new(_child::GskRenderNode, _clip::GskRoundedRectLike)
        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(GskRoundedRectLike, ret)
        ret2
    end
    function ShadowNode_new(_child::GskRenderNode, _shadows)
        _shadows_arr = convert(Vector{_GskShadow}, _shadows)
        _n_shadows = length(_shadows)
        ret = ccall(("gsk_shadow_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GskRenderNode}, Ptr{_GskShadow}, UInt64), _child, _shadows_arr, _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(GskShadowLike, ret)
        ret2
    end
    function TextNode_new(_font::PangoFont, _glyphs::PangoGlyphStringLike, _color::GdkRGBALike, _offset::GraphenePointLike)
        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(GdkRGBALike, 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)
        ret2 = collect(unsafe_wrap(Vector{_PangoGlyphInfo}, ret, m_n_glyphs[]))
        _n_glyphs = m_n_glyphs[]
        ret2
    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(GraphenePointLike, 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::GrapheneRectLike)
        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 TextureScaleNode_new(_texture::GdkTexture, _bounds::GrapheneRectLike, _filter)
        ret = ccall(("gsk_texture_scale_node_new", libgtk4), Ptr{GskRenderNode}, (Ptr{GObject}, Ptr{_GrapheneRect}, UInt32), _texture, _bounds, _filter)
        ret2 = convert(GskRenderNode, ret)
        ret2
    end
    function get_filter(instance::GskTextureScaleNode)
        ret = ccall(("gsk_texture_scale_node_get_filter", libgtk4), UInt32, (Ptr{GskRenderNode},), instance)
        ret2 = ScalingFilter(ret)
        ret2
    end
    function get_texture(instance::GskTextureScaleNode)
        ret = ccall(("gsk_texture_scale_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
    function VulkanRenderer_new()
        ret = ccall(("gsk_vulkan_renderer_new", libgtk4), Ptr{GObject}, ())
        ret2 = GskVulkanRendererLeaf(ret, true)
        ret2
    end
end
