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