quote
$(Expr(:toplevel, quote
    const gboxed_types = Any[]
    begin
        struct _GrapheneSimd4F
            x::Float32
            y::Float32
            z::Float32
            w::Float32
        end
        mutable struct GrapheneSimd4F
            handle::Ptr{_GrapheneSimd4F}
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneSimd4F}}, box::GrapheneSimd4F) = begin
                    convert(Ptr{_GrapheneSimd4F}, box.handle)
                end
            convert(::Type{GrapheneSimd4F}, p::Ptr{_GrapheneSimd4F}, owns = false) = begin
                    GrapheneSimd4F(p, owns)
                end
            const GrapheneSimd4FLike = Union{Ref{_GrapheneSimd4F}, GrapheneSimd4F}
            convert(::Type{GrapheneSimd4FLike}, p, owns) = begin
                    convert(GrapheneSimd4F, p, owns)
                end
        end
    end
    begin
        struct _GrapheneVec3
            value::_GrapheneSimd4F
        end
        mutable struct GrapheneVec3 <: GBoxed
            handle::Ptr{_GrapheneVec3}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneVec3) = begin
                        ccall(("graphene_vec3_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneVec3}}, box::GrapheneVec3) = begin
                    convert(Ptr{_GrapheneVec3}, box.handle)
                end
            convert(::Type{GrapheneVec3}, p::Ptr{_GrapheneVec3}, owns = false) = begin
                    GrapheneVec3(p, owns)
                end
            const GrapheneVec3Like = Union{Ref{_GrapheneVec3}, GrapheneVec3}
            convert(::Type{GrapheneVec3Like}, p, owns) = begin
                    convert(GrapheneVec3, p, owns)
                end
        end
    end
    begin
        struct _GrapheneSimd4X4F
            x::_GrapheneSimd4F
            y::_GrapheneSimd4F
            z::_GrapheneSimd4F
            w::_GrapheneSimd4F
        end
        mutable struct GrapheneSimd4X4F
            handle::Ptr{_GrapheneSimd4X4F}
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneSimd4X4F}}, box::GrapheneSimd4X4F) = begin
                    convert(Ptr{_GrapheneSimd4X4F}, box.handle)
                end
            convert(::Type{GrapheneSimd4X4F}, p::Ptr{_GrapheneSimd4X4F}, owns = false) = begin
                    GrapheneSimd4X4F(p, owns)
                end
            const GrapheneSimd4X4FLike = Union{Ref{_GrapheneSimd4X4F}, GrapheneSimd4X4F}
            convert(::Type{GrapheneSimd4X4FLike}, p, owns) = begin
                    convert(GrapheneSimd4X4F, p, owns)
                end
        end
    end
    begin
        struct _GrapheneSize
            width::Float32
            height::Float32
        end
        mutable struct GrapheneSize <: GBoxed
            handle::Ptr{_GrapheneSize}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneSize) = begin
                        ccall(("graphene_size_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneSize}}, box::GrapheneSize) = begin
                    convert(Ptr{_GrapheneSize}, box.handle)
                end
            convert(::Type{GrapheneSize}, p::Ptr{_GrapheneSize}, owns = false) = begin
                    GrapheneSize(p, owns)
                end
            const GrapheneSizeLike = Union{Ref{_GrapheneSize}, GrapheneSize}
            convert(::Type{GrapheneSizeLike}, p, owns) = begin
                    convert(GrapheneSize, p, owns)
                end
        end
    end
    begin
        struct _GrapheneBox
            min::_GrapheneVec3
            max::_GrapheneVec3
        end
        mutable struct GrapheneBox <: GBoxed
            handle::Ptr{_GrapheneBox}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneBox) = begin
                        ccall(("graphene_box_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneBox}}, box::GrapheneBox) = begin
                    convert(Ptr{_GrapheneBox}, box.handle)
                end
            convert(::Type{GrapheneBox}, p::Ptr{_GrapheneBox}, owns = false) = begin
                    GrapheneBox(p, owns)
                end
            const GrapheneBoxLike = Union{Ref{_GrapheneBox}, GrapheneBox}
            convert(::Type{GrapheneBoxLike}, p, owns) = begin
                    convert(GrapheneBox, p, owns)
                end
        end
    end
    begin
        struct _GrapheneEuler
            angles::_GrapheneVec3
            order::UInt32
        end
        mutable struct GrapheneEuler <: GBoxed
            handle::Ptr{_GrapheneEuler}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneEuler) = begin
                        ccall(("graphene_euler_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneEuler}}, box::GrapheneEuler) = begin
                    convert(Ptr{_GrapheneEuler}, box.handle)
                end
            convert(::Type{GrapheneEuler}, p::Ptr{_GrapheneEuler}, owns = false) = begin
                    GrapheneEuler(p, owns)
                end
            const GrapheneEulerLike = Union{Ref{_GrapheneEuler}, GrapheneEuler}
            convert(::Type{GrapheneEulerLike}, p, owns) = begin
                    convert(GrapheneEuler, p, owns)
                end
        end
    end
    begin
        mutable struct GrapheneFrustum <: GBoxed
            handle::Ptr{GrapheneFrustum}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneFrustum) = begin
                        ccall(("graphene_frustum_get_type", libgraphene), GType, ())
                    end
                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
        end
        const GrapheneFrustumLike = GrapheneFrustum
        const _GrapheneFrustum = GrapheneFrustum
    end
    begin
        struct _GrapheneMatrix
            value::_GrapheneSimd4X4F
        end
        mutable struct GrapheneMatrix <: GBoxed
            handle::Ptr{_GrapheneMatrix}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneMatrix) = begin
                        ccall(("graphene_matrix_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneMatrix}}, box::GrapheneMatrix) = begin
                    convert(Ptr{_GrapheneMatrix}, box.handle)
                end
            convert(::Type{GrapheneMatrix}, p::Ptr{_GrapheneMatrix}, owns = false) = begin
                    GrapheneMatrix(p, owns)
                end
            const GrapheneMatrixLike = Union{Ref{_GrapheneMatrix}, GrapheneMatrix}
            convert(::Type{GrapheneMatrixLike}, p, owns) = begin
                    convert(GrapheneMatrix, p, owns)
                end
        end
    end
    begin
        struct _GraphenePlane
            normal::_GrapheneVec3
            constant::Float32
        end
        mutable struct GraphenePlane <: GBoxed
            handle::Ptr{_GraphenePlane}
            begin
                (GLib.g_type(::Type{T}) where T <: GraphenePlane) = begin
                        ccall(("graphene_plane_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GraphenePlane}}, box::GraphenePlane) = begin
                    convert(Ptr{_GraphenePlane}, box.handle)
                end
            convert(::Type{GraphenePlane}, p::Ptr{_GraphenePlane}, owns = false) = begin
                    GraphenePlane(p, owns)
                end
            const GraphenePlaneLike = Union{Ref{_GraphenePlane}, GraphenePlane}
            convert(::Type{GraphenePlaneLike}, p, owns) = begin
                    convert(GraphenePlane, p, owns)
                end
        end
    end
    begin
        struct _GraphenePoint
            x::Float32
            y::Float32
        end
        mutable struct GraphenePoint <: GBoxed
            handle::Ptr{_GraphenePoint}
            begin
                (GLib.g_type(::Type{T}) where T <: GraphenePoint) = begin
                        ccall(("graphene_point_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GraphenePoint}}, box::GraphenePoint) = begin
                    convert(Ptr{_GraphenePoint}, box.handle)
                end
            convert(::Type{GraphenePoint}, p::Ptr{_GraphenePoint}, owns = false) = begin
                    GraphenePoint(p, owns)
                end
            const GraphenePointLike = Union{Ref{_GraphenePoint}, GraphenePoint}
            convert(::Type{GraphenePointLike}, p, owns) = begin
                    convert(GraphenePoint, p, owns)
                end
        end
    end
    begin
        struct _GraphenePoint3D
            x::Float32
            y::Float32
            z::Float32
        end
        mutable struct GraphenePoint3D <: GBoxed
            handle::Ptr{_GraphenePoint3D}
            begin
                (GLib.g_type(::Type{T}) where T <: GraphenePoint3D) = begin
                        ccall(("graphene_point3d_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GraphenePoint3D}}, box::GraphenePoint3D) = begin
                    convert(Ptr{_GraphenePoint3D}, box.handle)
                end
            convert(::Type{GraphenePoint3D}, p::Ptr{_GraphenePoint3D}, owns = false) = begin
                    GraphenePoint3D(p, owns)
                end
            const GraphenePoint3DLike = Union{Ref{_GraphenePoint3D}, GraphenePoint3D}
            convert(::Type{GraphenePoint3DLike}, p, owns) = begin
                    convert(GraphenePoint3D, p, owns)
                end
        end
    end
    begin
        mutable struct GrapheneQuad <: GBoxed
            handle::Ptr{GrapheneQuad}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneQuad) = begin
                        ccall(("graphene_quad_get_type", libgraphene), GType, ())
                    end
                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
        end
        const GrapheneQuadLike = GrapheneQuad
        const _GrapheneQuad = GrapheneQuad
    end
    begin
        struct _GrapheneQuaternion
            x::Float32
            y::Float32
            z::Float32
            w::Float32
        end
        mutable struct GrapheneQuaternion <: GBoxed
            handle::Ptr{_GrapheneQuaternion}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneQuaternion) = begin
                        ccall(("graphene_quaternion_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneQuaternion}}, box::GrapheneQuaternion) = begin
                    convert(Ptr{_GrapheneQuaternion}, box.handle)
                end
            convert(::Type{GrapheneQuaternion}, p::Ptr{_GrapheneQuaternion}, owns = false) = begin
                    GrapheneQuaternion(p, owns)
                end
            const GrapheneQuaternionLike = Union{Ref{_GrapheneQuaternion}, GrapheneQuaternion}
            convert(::Type{GrapheneQuaternionLike}, p, owns) = begin
                    convert(GrapheneQuaternion, p, owns)
                end
        end
    end
    begin
        struct _GrapheneRay
            origin::_GrapheneVec3
            direction::_GrapheneVec3
        end
        mutable struct GrapheneRay <: GBoxed
            handle::Ptr{_GrapheneRay}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneRay) = begin
                        ccall(("graphene_ray_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneRay}}, box::GrapheneRay) = begin
                    convert(Ptr{_GrapheneRay}, box.handle)
                end
            convert(::Type{GrapheneRay}, p::Ptr{_GrapheneRay}, owns = false) = begin
                    GrapheneRay(p, owns)
                end
            const GrapheneRayLike = Union{Ref{_GrapheneRay}, GrapheneRay}
            convert(::Type{GrapheneRayLike}, p, owns) = begin
                    convert(GrapheneRay, p, owns)
                end
        end
    end
    begin
        struct _GrapheneRect
            origin::_GraphenePoint
            size::_GrapheneSize
        end
        mutable struct GrapheneRect <: GBoxed
            handle::Ptr{_GrapheneRect}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneRect) = begin
                        ccall(("graphene_rect_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneRect}}, box::GrapheneRect) = begin
                    convert(Ptr{_GrapheneRect}, box.handle)
                end
            convert(::Type{GrapheneRect}, p::Ptr{_GrapheneRect}, owns = false) = begin
                    GrapheneRect(p, owns)
                end
            const GrapheneRectLike = Union{Ref{_GrapheneRect}, GrapheneRect}
            convert(::Type{GrapheneRectLike}, p, owns) = begin
                    convert(GrapheneRect, p, owns)
                end
        end
    end
    begin
        struct _GrapheneSphere
            center::_GrapheneVec3
            radius::Float32
        end
        mutable struct GrapheneSphere <: GBoxed
            handle::Ptr{_GrapheneSphere}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneSphere) = begin
                        ccall(("graphene_sphere_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneSphere}}, box::GrapheneSphere) = begin
                    convert(Ptr{_GrapheneSphere}, box.handle)
                end
            convert(::Type{GrapheneSphere}, p::Ptr{_GrapheneSphere}, owns = false) = begin
                    GrapheneSphere(p, owns)
                end
            const GrapheneSphereLike = Union{Ref{_GrapheneSphere}, GrapheneSphere}
            convert(::Type{GrapheneSphereLike}, p, owns) = begin
                    convert(GrapheneSphere, p, owns)
                end
        end
    end
    begin
        struct _GrapheneTriangle
            a::_GrapheneVec3
            b::_GrapheneVec3
            c::_GrapheneVec3
        end
        mutable struct GrapheneTriangle <: GBoxed
            handle::Ptr{_GrapheneTriangle}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneTriangle) = begin
                        ccall(("graphene_triangle_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneTriangle}}, box::GrapheneTriangle) = begin
                    convert(Ptr{_GrapheneTriangle}, box.handle)
                end
            convert(::Type{GrapheneTriangle}, p::Ptr{_GrapheneTriangle}, owns = false) = begin
                    GrapheneTriangle(p, owns)
                end
            const GrapheneTriangleLike = Union{Ref{_GrapheneTriangle}, GrapheneTriangle}
            convert(::Type{GrapheneTriangleLike}, p, owns) = begin
                    convert(GrapheneTriangle, p, owns)
                end
        end
    end
    begin
        struct _GrapheneVec2
            value::_GrapheneSimd4F
        end
        mutable struct GrapheneVec2 <: GBoxed
            handle::Ptr{_GrapheneVec2}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneVec2) = begin
                        ccall(("graphene_vec2_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneVec2}}, box::GrapheneVec2) = begin
                    convert(Ptr{_GrapheneVec2}, box.handle)
                end
            convert(::Type{GrapheneVec2}, p::Ptr{_GrapheneVec2}, owns = false) = begin
                    GrapheneVec2(p, owns)
                end
            const GrapheneVec2Like = Union{Ref{_GrapheneVec2}, GrapheneVec2}
            convert(::Type{GrapheneVec2Like}, p, owns) = begin
                    convert(GrapheneVec2, p, owns)
                end
        end
    end
    begin
        struct _GrapheneVec4
            value::_GrapheneSimd4F
        end
        mutable struct GrapheneVec4 <: GBoxed
            handle::Ptr{_GrapheneVec4}
            begin
                (GLib.g_type(::Type{T}) where T <: GrapheneVec4) = begin
                        ccall(("graphene_vec4_get_type", libgraphene), GType, ())
                    end
                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
        end
        begin
            unsafe_convert(::Type{Ptr{_GrapheneVec4}}, box::GrapheneVec4) = begin
                    convert(Ptr{_GrapheneVec4}, box.handle)
                end
            convert(::Type{GrapheneVec4}, p::Ptr{_GrapheneVec4}, owns = false) = begin
                    GrapheneVec4(p, owns)
                end
            const GrapheneVec4Like = Union{Ref{_GrapheneVec4}, GrapheneVec4}
            convert(::Type{GrapheneVec4Like}, p, owns) = begin
                    convert(GrapheneVec4, p, owns)
                end
        end
    end
    gboxed_cache_init() = begin
            append!(GLib.gboxed_types, gboxed_types)
        end
    const gtype_wrapper_cache = Dict{Symbol, Type}()
    begin
        gtype_wrapper_cache_init() = begin
                merge!(GLib.gtype_wrappers, gtype_wrapper_cache)
            end
    end
    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))
end
