begin
    const gboxed_types = Any[]
    struct _GrapheneSimd4F
        x::Float32
        y::Float32
        z::Float32
        w::Float32
    end
    mutable struct GrapheneSimd4F
        handle::Ptr{_GrapheneSimd4F}
    end
    unsafe_convert(::Type{Ptr{_GrapheneSimd4F}}, box::GrapheneSimd4F) = convert(Ptr{_GrapheneSimd4F}, box.handle)
    convert(::Type{GrapheneSimd4F}, p::Ptr{_GrapheneSimd4F}, owns = false) = GrapheneSimd4F(p, owns)
    const GrapheneSimd4FLike = Union{Ref{_GrapheneSimd4F}, GrapheneSimd4F}
    convert(::Type{GrapheneSimd4FLike}, p, owns) = convert(GrapheneSimd4F, p, owns)
    struct _GrapheneVec3
        value::_GrapheneSimd4F
    end
    mutable struct GrapheneVec3 <: GBoxed
        handle::Ptr{_GrapheneVec3}
        (GLib.g_type(::Type{T}) where T <: GrapheneVec3) = ccall(("graphene_vec3_get_type", libgraphene), GType, ())
        function GrapheneVec3(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneVec3}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneVec3)
    end
    unsafe_convert(::Type{Ptr{_GrapheneVec3}}, box::GrapheneVec3) = convert(Ptr{_GrapheneVec3}, box.handle)
    convert(::Type{GrapheneVec3}, p::Ptr{_GrapheneVec3}, owns = false) = GrapheneVec3(p, owns)
    const GrapheneVec3Like = Union{Ref{_GrapheneVec3}, GrapheneVec3}
    convert(::Type{GrapheneVec3Like}, p, owns) = convert(GrapheneVec3, p, owns)
    struct _GrapheneSimd4X4F
        x::_GrapheneSimd4F
        y::_GrapheneSimd4F
        z::_GrapheneSimd4F
        w::_GrapheneSimd4F
    end
    mutable struct GrapheneSimd4X4F
        handle::Ptr{_GrapheneSimd4X4F}
    end
    unsafe_convert(::Type{Ptr{_GrapheneSimd4X4F}}, box::GrapheneSimd4X4F) = convert(Ptr{_GrapheneSimd4X4F}, box.handle)
    convert(::Type{GrapheneSimd4X4F}, p::Ptr{_GrapheneSimd4X4F}, owns = false) = GrapheneSimd4X4F(p, owns)
    const GrapheneSimd4X4FLike = Union{Ref{_GrapheneSimd4X4F}, GrapheneSimd4X4F}
    convert(::Type{GrapheneSimd4X4FLike}, p, owns) = convert(GrapheneSimd4X4F, p, owns)
    struct _GrapheneSize
        width::Float32
        height::Float32
    end
    mutable struct GrapheneSize <: GBoxed
        handle::Ptr{_GrapheneSize}
        (GLib.g_type(::Type{T}) where T <: GrapheneSize) = ccall(("graphene_size_get_type", libgraphene), GType, ())
        function GrapheneSize(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneSize}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneSize)
    end
    unsafe_convert(::Type{Ptr{_GrapheneSize}}, box::GrapheneSize) = convert(Ptr{_GrapheneSize}, box.handle)
    convert(::Type{GrapheneSize}, p::Ptr{_GrapheneSize}, owns = false) = GrapheneSize(p, owns)
    const GrapheneSizeLike = Union{Ref{_GrapheneSize}, GrapheneSize}
    convert(::Type{GrapheneSizeLike}, p, owns) = convert(GrapheneSize, p, owns)
    struct _GrapheneBox
        min::_GrapheneVec3
        max::_GrapheneVec3
    end
    mutable struct GrapheneBox <: GBoxed
        handle::Ptr{_GrapheneBox}
        (GLib.g_type(::Type{T}) where T <: GrapheneBox) = ccall(("graphene_box_get_type", libgraphene), GType, ())
        function GrapheneBox(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneBox}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneBox)
    end
    unsafe_convert(::Type{Ptr{_GrapheneBox}}, box::GrapheneBox) = convert(Ptr{_GrapheneBox}, box.handle)
    convert(::Type{GrapheneBox}, p::Ptr{_GrapheneBox}, owns = false) = GrapheneBox(p, owns)
    const GrapheneBoxLike = Union{Ref{_GrapheneBox}, GrapheneBox}
    convert(::Type{GrapheneBoxLike}, p, owns) = convert(GrapheneBox, p, owns)
    struct _GrapheneEuler
        angles::_GrapheneVec3
        order::UInt32
    end
    mutable struct GrapheneEuler <: GBoxed
        handle::Ptr{_GrapheneEuler}
        (GLib.g_type(::Type{T}) where T <: GrapheneEuler) = ccall(("graphene_euler_get_type", libgraphene), GType, ())
        function GrapheneEuler(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneEuler}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneEuler)
    end
    unsafe_convert(::Type{Ptr{_GrapheneEuler}}, box::GrapheneEuler) = convert(Ptr{_GrapheneEuler}, box.handle)
    convert(::Type{GrapheneEuler}, p::Ptr{_GrapheneEuler}, owns = false) = GrapheneEuler(p, owns)
    const GrapheneEulerLike = Union{Ref{_GrapheneEuler}, GrapheneEuler}
    convert(::Type{GrapheneEulerLike}, p, owns) = convert(GrapheneEuler, p, owns)
    mutable struct GrapheneFrustum <: GBoxed
        handle::Ptr{GrapheneFrustum}
        (GLib.g_type(::Type{T}) where T <: GrapheneFrustum) = ccall(("graphene_frustum_get_type", libgraphene), GType, ())
        function GrapheneFrustum(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneFrustum)
    end
    const GrapheneFrustumLike = GrapheneFrustum
    const _GrapheneFrustum = GrapheneFrustum
    struct _GrapheneMatrix
        value::_GrapheneSimd4X4F
    end
    mutable struct GrapheneMatrix <: GBoxed
        handle::Ptr{_GrapheneMatrix}
        (GLib.g_type(::Type{T}) where T <: GrapheneMatrix) = ccall(("graphene_matrix_get_type", libgraphene), GType, ())
        function GrapheneMatrix(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneMatrix}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneMatrix)
    end
    unsafe_convert(::Type{Ptr{_GrapheneMatrix}}, box::GrapheneMatrix) = convert(Ptr{_GrapheneMatrix}, box.handle)
    convert(::Type{GrapheneMatrix}, p::Ptr{_GrapheneMatrix}, owns = false) = GrapheneMatrix(p, owns)
    const GrapheneMatrixLike = Union{Ref{_GrapheneMatrix}, GrapheneMatrix}
    convert(::Type{GrapheneMatrixLike}, p, owns) = convert(GrapheneMatrix, p, owns)
    struct _GraphenePlane
        normal::_GrapheneVec3
        constant::Float32
    end
    mutable struct GraphenePlane <: GBoxed
        handle::Ptr{_GraphenePlane}
        (GLib.g_type(::Type{T}) where T <: GraphenePlane) = ccall(("graphene_plane_get_type", libgraphene), GType, ())
        function GraphenePlane(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GraphenePlane}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GraphenePlane)
    end
    unsafe_convert(::Type{Ptr{_GraphenePlane}}, box::GraphenePlane) = convert(Ptr{_GraphenePlane}, box.handle)
    convert(::Type{GraphenePlane}, p::Ptr{_GraphenePlane}, owns = false) = GraphenePlane(p, owns)
    const GraphenePlaneLike = Union{Ref{_GraphenePlane}, GraphenePlane}
    convert(::Type{GraphenePlaneLike}, p, owns) = convert(GraphenePlane, p, owns)
    struct _GraphenePoint
        x::Float32
        y::Float32
    end
    mutable struct GraphenePoint <: GBoxed
        handle::Ptr{_GraphenePoint}
        (GLib.g_type(::Type{T}) where T <: GraphenePoint) = ccall(("graphene_point_get_type", libgraphene), GType, ())
        function GraphenePoint(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GraphenePoint}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GraphenePoint)
    end
    unsafe_convert(::Type{Ptr{_GraphenePoint}}, box::GraphenePoint) = convert(Ptr{_GraphenePoint}, box.handle)
    convert(::Type{GraphenePoint}, p::Ptr{_GraphenePoint}, owns = false) = GraphenePoint(p, owns)
    const GraphenePointLike = Union{Ref{_GraphenePoint}, GraphenePoint}
    convert(::Type{GraphenePointLike}, p, owns) = convert(GraphenePoint, p, owns)
    struct _GraphenePoint3D
        x::Float32
        y::Float32
        z::Float32
    end
    mutable struct GraphenePoint3D <: GBoxed
        handle::Ptr{_GraphenePoint3D}
        (GLib.g_type(::Type{T}) where T <: GraphenePoint3D) = ccall(("graphene_point3d_get_type", libgraphene), GType, ())
        function GraphenePoint3D(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GraphenePoint3D}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GraphenePoint3D)
    end
    unsafe_convert(::Type{Ptr{_GraphenePoint3D}}, box::GraphenePoint3D) = convert(Ptr{_GraphenePoint3D}, box.handle)
    convert(::Type{GraphenePoint3D}, p::Ptr{_GraphenePoint3D}, owns = false) = GraphenePoint3D(p, owns)
    const GraphenePoint3DLike = Union{Ref{_GraphenePoint3D}, GraphenePoint3D}
    convert(::Type{GraphenePoint3DLike}, p, owns) = convert(GraphenePoint3D, p, owns)
    mutable struct GrapheneQuad <: GBoxed
        handle::Ptr{GrapheneQuad}
        (GLib.g_type(::Type{T}) where T <: GrapheneQuad) = ccall(("graphene_quad_get_type", libgraphene), GType, ())
        function GrapheneQuad(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneQuad)
    end
    const GrapheneQuadLike = GrapheneQuad
    const _GrapheneQuad = GrapheneQuad
    struct _GrapheneQuaternion
        x::Float32
        y::Float32
        z::Float32
        w::Float32
    end
    mutable struct GrapheneQuaternion <: GBoxed
        handle::Ptr{_GrapheneQuaternion}
        (GLib.g_type(::Type{T}) where T <: GrapheneQuaternion) = ccall(("graphene_quaternion_get_type", libgraphene), GType, ())
        function GrapheneQuaternion(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneQuaternion}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneQuaternion)
    end
    unsafe_convert(::Type{Ptr{_GrapheneQuaternion}}, box::GrapheneQuaternion) = convert(Ptr{_GrapheneQuaternion}, box.handle)
    convert(::Type{GrapheneQuaternion}, p::Ptr{_GrapheneQuaternion}, owns = false) = GrapheneQuaternion(p, owns)
    const GrapheneQuaternionLike = Union{Ref{_GrapheneQuaternion}, GrapheneQuaternion}
    convert(::Type{GrapheneQuaternionLike}, p, owns) = convert(GrapheneQuaternion, p, owns)
    struct _GrapheneRay
        origin::_GrapheneVec3
        direction::_GrapheneVec3
    end
    mutable struct GrapheneRay <: GBoxed
        handle::Ptr{_GrapheneRay}
        (GLib.g_type(::Type{T}) where T <: GrapheneRay) = ccall(("graphene_ray_get_type", libgraphene), GType, ())
        function GrapheneRay(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneRay}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneRay)
    end
    unsafe_convert(::Type{Ptr{_GrapheneRay}}, box::GrapheneRay) = convert(Ptr{_GrapheneRay}, box.handle)
    convert(::Type{GrapheneRay}, p::Ptr{_GrapheneRay}, owns = false) = GrapheneRay(p, owns)
    const GrapheneRayLike = Union{Ref{_GrapheneRay}, GrapheneRay}
    convert(::Type{GrapheneRayLike}, p, owns) = convert(GrapheneRay, p, owns)
    struct _GrapheneRect
        origin::_GraphenePoint
        size::_GrapheneSize
    end
    mutable struct GrapheneRect <: GBoxed
        handle::Ptr{_GrapheneRect}
        (GLib.g_type(::Type{T}) where T <: GrapheneRect) = ccall(("graphene_rect_get_type", libgraphene), GType, ())
        function GrapheneRect(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneRect}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneRect)
    end
    unsafe_convert(::Type{Ptr{_GrapheneRect}}, box::GrapheneRect) = convert(Ptr{_GrapheneRect}, box.handle)
    convert(::Type{GrapheneRect}, p::Ptr{_GrapheneRect}, owns = false) = GrapheneRect(p, owns)
    const GrapheneRectLike = Union{Ref{_GrapheneRect}, GrapheneRect}
    convert(::Type{GrapheneRectLike}, p, owns) = convert(GrapheneRect, p, owns)
    struct _GrapheneSphere
        center::_GrapheneVec3
        radius::Float32
    end
    mutable struct GrapheneSphere <: GBoxed
        handle::Ptr{_GrapheneSphere}
        (GLib.g_type(::Type{T}) where T <: GrapheneSphere) = ccall(("graphene_sphere_get_type", libgraphene), GType, ())
        function GrapheneSphere(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneSphere}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneSphere)
    end
    unsafe_convert(::Type{Ptr{_GrapheneSphere}}, box::GrapheneSphere) = convert(Ptr{_GrapheneSphere}, box.handle)
    convert(::Type{GrapheneSphere}, p::Ptr{_GrapheneSphere}, owns = false) = GrapheneSphere(p, owns)
    const GrapheneSphereLike = Union{Ref{_GrapheneSphere}, GrapheneSphere}
    convert(::Type{GrapheneSphereLike}, p, owns) = convert(GrapheneSphere, p, owns)
    struct _GrapheneTriangle
        a::_GrapheneVec3
        b::_GrapheneVec3
        c::_GrapheneVec3
    end
    mutable struct GrapheneTriangle <: GBoxed
        handle::Ptr{_GrapheneTriangle}
        (GLib.g_type(::Type{T}) where T <: GrapheneTriangle) = ccall(("graphene_triangle_get_type", libgraphene), GType, ())
        function GrapheneTriangle(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneTriangle}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneTriangle)
    end
    unsafe_convert(::Type{Ptr{_GrapheneTriangle}}, box::GrapheneTriangle) = convert(Ptr{_GrapheneTriangle}, box.handle)
    convert(::Type{GrapheneTriangle}, p::Ptr{_GrapheneTriangle}, owns = false) = GrapheneTriangle(p, owns)
    const GrapheneTriangleLike = Union{Ref{_GrapheneTriangle}, GrapheneTriangle}
    convert(::Type{GrapheneTriangleLike}, p, owns) = convert(GrapheneTriangle, p, owns)
    struct _GrapheneVec2
        value::_GrapheneSimd4F
    end
    mutable struct GrapheneVec2 <: GBoxed
        handle::Ptr{_GrapheneVec2}
        (GLib.g_type(::Type{T}) where T <: GrapheneVec2) = ccall(("graphene_vec2_get_type", libgraphene), GType, ())
        function GrapheneVec2(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneVec2}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneVec2)
    end
    unsafe_convert(::Type{Ptr{_GrapheneVec2}}, box::GrapheneVec2) = convert(Ptr{_GrapheneVec2}, box.handle)
    convert(::Type{GrapheneVec2}, p::Ptr{_GrapheneVec2}, owns = false) = GrapheneVec2(p, owns)
    const GrapheneVec2Like = Union{Ref{_GrapheneVec2}, GrapheneVec2}
    convert(::Type{GrapheneVec2Like}, p, owns) = convert(GrapheneVec2, p, owns)
    struct _GrapheneVec4
        value::_GrapheneSimd4F
    end
    mutable struct GrapheneVec4 <: GBoxed
        handle::Ptr{_GrapheneVec4}
        (GLib.g_type(::Type{T}) where T <: GrapheneVec4) = ccall(("graphene_vec4_get_type", libgraphene), GType, ())
        function GrapheneVec4(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GrapheneVec4}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GrapheneVec4)
    end
    unsafe_convert(::Type{Ptr{_GrapheneVec4}}, box::GrapheneVec4) = convert(Ptr{_GrapheneVec4}, box.handle)
    convert(::Type{GrapheneVec4}, p::Ptr{_GrapheneVec4}, owns = false) = GrapheneVec4(p, owns)
    const GrapheneVec4Like = Union{Ref{_GrapheneVec4}, GrapheneVec4}
    convert(::Type{GrapheneVec4Like}, p, owns) = convert(GrapheneVec4, p, owns)
    gboxed_cache_init() = append!(GLib.gboxed_types, gboxed_types)
    const gtype_wrapper_cache = Dict{Symbol, Type}()
    gtype_wrapper_cache_init() = merge!(GLib.gtype_wrappers, gtype_wrapper_cache)
    function GrapheneVec3()
        G_.Vec3_alloc()
    end
    function GrapheneSize()
        G_.Size_alloc()
    end
    function GrapheneBox()
        G_.Box_alloc()
    end
    function GrapheneEuler()
        G_.Euler_alloc()
    end
    function GrapheneFrustum()
        G_.Frustum_alloc()
    end
    function GrapheneMatrix()
        G_.Matrix_alloc()
    end
    function GraphenePlane()
        G_.Plane_alloc()
    end
    function GraphenePoint()
        G_.Point_alloc()
    end
    function GraphenePoint3D()
        G_.Point3D_alloc()
    end
    function GrapheneQuad()
        G_.Quad_alloc()
    end
    function GrapheneQuaternion()
        G_.Quaternion_alloc()
    end
    function GrapheneRay()
        G_.Ray_alloc()
    end
    function GrapheneSphere()
        G_.Sphere_alloc()
    end
    function GrapheneTriangle()
        G_.Triangle_alloc()
    end
    function GrapheneVec2()
        G_.Vec2_alloc()
    end
    function GrapheneVec4()
        G_.Vec4_alloc()
    end
    export GrapheneSimd4F, _GrapheneSimd4F, GrapheneSimd4FLike, GrapheneVec3, _GrapheneVec3, GrapheneVec3Like, GrapheneSimd4X4F, _GrapheneSimd4X4F, GrapheneSimd4X4FLike, GrapheneSize, _GrapheneSize, GrapheneSizeLike, GrapheneBox, GrapheneBoxLike, _GrapheneBox, GrapheneEuler, GrapheneEulerLike, _GrapheneEuler, GrapheneFrustum, GrapheneFrustumLike, _GrapheneFrustum, GrapheneMatrix, GrapheneMatrixLike, _GrapheneMatrix, GraphenePlane, GraphenePlaneLike, _GraphenePlane, GraphenePoint, GraphenePointLike, _GraphenePoint, GraphenePoint3D, GraphenePoint3DLike, _GraphenePoint3D, GrapheneQuad, GrapheneQuadLike, _GrapheneQuad, GrapheneQuaternion, GrapheneQuaternionLike, _GrapheneQuaternion, GrapheneRay, GrapheneRayLike, _GrapheneRay, GrapheneRect, GrapheneRectLike, _GrapheneRect, GrapheneSphere, GrapheneSphereLike, _GrapheneSphere, GrapheneTriangle, GrapheneTriangleLike, _GrapheneTriangle, GrapheneVec2, GrapheneVec2Like, _GrapheneVec2, GrapheneVec4, GrapheneVec4Like, _GrapheneVec4
end
