quote
$(Expr(:toplevel, quote
    const gboxed_types = Any[]
    begin
        mutable struct cairoContext <: GBoxed
            handle::Ptr{cairoContext}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoContext) = begin
                        ccall(("cairo_gobject_context_get_type", libcairo_gobject), GType, ())
                    end
                function cairoContext(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, cairoContext)
            end
        end
        const cairoContextLike = cairoContext
    end
    begin
        mutable struct cairoDevice <: GBoxed
            handle::Ptr{cairoDevice}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoDevice) = begin
                        ccall(("cairo_gobject_device_get_type", libcairo_gobject), GType, ())
                    end
                function cairoDevice(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, cairoDevice)
            end
        end
        const cairoDeviceLike = cairoDevice
    end
    begin
        mutable struct cairoSurface <: GBoxed
            handle::Ptr{cairoSurface}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoSurface) = begin
                        ccall(("cairo_gobject_surface_get_type", libcairo_gobject), GType, ())
                    end
                function cairoSurface(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, cairoSurface)
            end
        end
        const cairoSurfaceLike = cairoSurface
    end
    begin
        mutable struct cairoMatrix
            handle::Ptr{cairoMatrix}
        end
        const cairoMatrixLike = cairoMatrix
    end
    begin
        mutable struct cairoPattern <: GBoxed
            handle::Ptr{cairoPattern}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoPattern) = begin
                        ccall(("cairo_gobject_pattern_get_type", libcairo_gobject), GType, ())
                    end
                function cairoPattern(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, cairoPattern)
            end
        end
        const cairoPatternLike = cairoPattern
    end
    begin
        mutable struct cairoRegion <: GBoxed
            handle::Ptr{cairoRegion}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoRegion) = begin
                        ccall(("cairo_gobject_region_get_type", libcairo_gobject), GType, ())
                    end
                function cairoRegion(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, cairoRegion)
            end
        end
        const cairoRegionLike = cairoRegion
    end
    begin
        mutable struct cairoFontOptions <: GBoxed
            handle::Ptr{cairoFontOptions}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoFontOptions) = begin
                        ccall(("cairo_gobject_font_options_get_type", libcairo_gobject), GType, ())
                    end
                function cairoFontOptions(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, cairoFontOptions)
            end
        end
        const cairoFontOptionsLike = cairoFontOptions
    end
    begin
        mutable struct cairoFontFace <: GBoxed
            handle::Ptr{cairoFontFace}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoFontFace) = begin
                        ccall(("cairo_gobject_font_face_get_type", libcairo_gobject), GType, ())
                    end
                function cairoFontFace(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, cairoFontFace)
            end
        end
        const cairoFontFaceLike = cairoFontFace
    end
    begin
        mutable struct cairoScaledFont <: GBoxed
            handle::Ptr{cairoScaledFont}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoScaledFont) = begin
                        ccall(("cairo_gobject_scaled_font_get_type", libcairo_gobject), GType, ())
                    end
                function cairoScaledFont(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, cairoScaledFont)
            end
        end
        const cairoScaledFontLike = cairoScaledFont
    end
    begin
        mutable struct cairoPath
            handle::Ptr{cairoPath}
        end
        const cairoPathLike = cairoPath
    end
    begin
        struct _cairoRectangle
            x::Float64
            y::Float64
            width::Float64
            height::Float64
        end
        mutable struct cairoRectangle <: GBoxed
            handle::Ptr{_cairoRectangle}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoRectangle) = begin
                        ccall(("cairo_gobject_rectangle_get_type", libcairo_gobject), GType, ())
                    end
                function cairoRectangle(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _cairoRectangle}
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, cairoRectangle)
            end
        end
        begin
            unsafe_convert(::Type{Ptr{_cairoRectangle}}, box::cairoRectangle) = begin
                    convert(Ptr{_cairoRectangle}, box.handle)
                end
            convert(::Type{cairoRectangle}, p::Ptr{_cairoRectangle}, owns = false) = begin
                    cairoRectangle(p, owns)
                end
            const cairoRectangleLike = Union{Ref{_cairoRectangle}, cairoRectangle}
            convert(::Type{cairoRectangleLike}, p, owns) = begin
                    convert(cairoRectangle, p, owns)
                end
        end
    end
    begin
        struct _cairoRectangleInt
            x::Int32
            y::Int32
            width::Int32
            height::Int32
        end
        mutable struct cairoRectangleInt <: GBoxed
            handle::Ptr{_cairoRectangleInt}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoRectangleInt) = begin
                        ccall(("cairo_gobject_rectangle_int_get_type", libcairo_gobject), GType, ())
                    end
                function cairoRectangleInt(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _cairoRectangleInt}
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, cairoRectangleInt)
            end
        end
        begin
            unsafe_convert(::Type{Ptr{_cairoRectangleInt}}, box::cairoRectangleInt) = begin
                    convert(Ptr{_cairoRectangleInt}, box.handle)
                end
            convert(::Type{cairoRectangleInt}, p::Ptr{_cairoRectangleInt}, owns = false) = begin
                    cairoRectangleInt(p, owns)
                end
            const cairoRectangleIntLike = Union{Ref{_cairoRectangleInt}, cairoRectangleInt}
            convert(::Type{cairoRectangleIntLike}, p, owns) = begin
                    convert(cairoRectangleInt, p, owns)
                end
        end
    end
    begin
        struct _cairoGlyph
            index::UInt64
            x::Float64
            y::Float64
        end
        mutable struct cairoGlyph <: GBoxed
            handle::Ptr{_cairoGlyph}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoGlyph) = begin
                        ccall(("cairo_gobject_glyph_get_type", libcairo_gobject), GType, ())
                    end
                function cairoGlyph(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _cairoGlyph}
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, cairoGlyph)
            end
        end
        begin
            unsafe_convert(::Type{Ptr{_cairoGlyph}}, box::cairoGlyph) = begin
                    convert(Ptr{_cairoGlyph}, box.handle)
                end
            convert(::Type{cairoGlyph}, p::Ptr{_cairoGlyph}, owns = false) = begin
                    cairoGlyph(p, owns)
                end
            const cairoGlyphLike = Union{Ref{_cairoGlyph}, cairoGlyph}
            convert(::Type{cairoGlyphLike}, p, owns) = begin
                    convert(cairoGlyph, p, owns)
                end
        end
    end
    begin
        struct _cairoTextCluster
            num_bytes::Int32
            num_glyphs::Int32
        end
        mutable struct cairoTextCluster <: GBoxed
            handle::Ptr{_cairoTextCluster}
            begin
                (GLib.g_type(::Type{T}) where T <: cairoTextCluster) = begin
                        ccall(("cairo_gobject_text_cluster_get_type", libcairo_gobject), GType, ())
                    end
                function cairoTextCluster(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _cairoTextCluster}
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, cairoTextCluster)
            end
        end
        begin
            unsafe_convert(::Type{Ptr{_cairoTextCluster}}, box::cairoTextCluster) = begin
                    convert(Ptr{_cairoTextCluster}, box.handle)
                end
            convert(::Type{cairoTextCluster}, p::Ptr{_cairoTextCluster}, owns = false) = begin
                    cairoTextCluster(p, owns)
                end
            const cairoTextClusterLike = Union{Ref{_cairoTextCluster}, cairoTextCluster}
            convert(::Type{cairoTextClusterLike}, p, owns) = begin
                    convert(cairoTextCluster, p, owns)
                end
        end
    end
    gboxed_cache_init() = begin
            append!(GLib.gboxed_types, gboxed_types)
        end
    export cairoContext, cairoDevice, cairoSurface, cairoMatrix, cairoPattern, cairoRegion, cairoFontOptions, cairoFontFace, cairoScaledFont, cairoPath, cairoRectangle, cairoRectangleLike, _cairoRectangle, cairoRectangleInt, cairoRectangleIntLike, _cairoRectangleInt, cairoGlyph, cairoGlyphLike, _cairoGlyph, cairoTextCluster, cairoTextClusterLike, _cairoTextCluster
end))
end
