const gboxed_types = Any[]
begin
    mutable struct PangoLanguage <: GBoxed
        handle::Ptr{PangoLanguage}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoLanguage) = begin
                    ccall(("pango_language_get_type", libpango), GType, ())
                end
            function PangoLanguage(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, PangoLanguage)
        end
    end
    const PangoLanguageLike = PangoLanguage
end
begin
    struct _PangoColor
        red::UInt16
        green::UInt16
        blue::UInt16
    end
    mutable struct PangoColor <: GBoxed
        handle::Ptr{_PangoColor}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoColor) = begin
                    ccall(("pango_color_get_type", libpango), GType, ())
                end
            function PangoColor(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoColor}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoColor)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoColor}}, box::PangoColor) = begin
                convert(Ptr{_PangoColor}, box.handle)
            end
        convert(::Type{PangoColor}, p::Ptr{_PangoColor}, owns = false) = begin
                PangoColor(p, owns)
            end
        const PangoColorLike = Union{Ref{_PangoColor}, PangoColor}
        convert(::Type{PangoColorLike}, p, owns) = begin
                convert(PangoColor, p, owns)
            end
    end
end
begin
    struct _PangoAttrClass
        type::UInt32
        copy::Ptr{Cvoid}
        destroy::Ptr{Cvoid}
        equal::Ptr{Cvoid}
    end
    mutable struct PangoAttrClass
        handle::Ptr{_PangoAttrClass}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrClass}}, box::PangoAttrClass) = begin
                convert(Ptr{_PangoAttrClass}, box.handle)
            end
        convert(::Type{PangoAttrClass}, p::Ptr{_PangoAttrClass}, owns = false) = begin
                PangoAttrClass(p, owns)
            end
        const PangoAttrClassLike = Union{Ref{_PangoAttrClass}, PangoAttrClass}
        convert(::Type{PangoAttrClassLike}, p, owns) = begin
                convert(PangoAttrClass, p, owns)
            end
    end
end
begin
    struct _PangoRectangle
        x::Int32
        y::Int32
        width::Int32
        height::Int32
    end
    mutable struct PangoRectangle
        handle::Ptr{_PangoRectangle}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoRectangle}}, box::PangoRectangle) = begin
                convert(Ptr{_PangoRectangle}, box.handle)
            end
        convert(::Type{PangoRectangle}, p::Ptr{_PangoRectangle}, owns = false) = begin
                PangoRectangle(p, owns)
            end
        const PangoRectangleLike = Union{Ref{_PangoRectangle}, PangoRectangle}
        convert(::Type{PangoRectangleLike}, p, owns) = begin
                convert(PangoRectangle, p, owns)
            end
    end
end
begin
    mutable struct PangoFontDescription <: GBoxed
        handle::Ptr{PangoFontDescription}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoFontDescription) = begin
                    ccall(("pango_font_description_get_type", libpango), GType, ())
                end
            function PangoFontDescription(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, PangoFontDescription)
        end
    end
    const PangoFontDescriptionLike = PangoFontDescription
end
begin
    struct _PangoAttribute
        klass::Ptr{_PangoAttrClass}
        start_index::UInt32
        end_index::UInt32
    end
    mutable struct PangoAttribute <: GBoxed
        handle::Ptr{_PangoAttribute}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoAttribute) = begin
                    ccall(("pango_attribute_get_type", libpango), GType, ())
                end
            function PangoAttribute(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoAttribute}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoAttribute)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttribute}}, box::PangoAttribute) = begin
                convert(Ptr{_PangoAttribute}, box.handle)
            end
        convert(::Type{PangoAttribute}, p::Ptr{_PangoAttribute}, owns = false) = begin
                PangoAttribute(p, owns)
            end
        const PangoAttributeLike = Union{Ref{_PangoAttribute}, PangoAttribute}
        convert(::Type{PangoAttributeLike}, p, owns) = begin
                convert(PangoAttribute, p, owns)
            end
    end
end
begin
    struct _PangoAnalysis
        shape_engine::Ptr{Nothing}
        lang_engine::Ptr{Nothing}
        font::Ptr{GObject}
        level::UInt8
        gravity::UInt8
        flags::UInt8
        script::UInt8
        language::Ptr{PangoLanguage}
        extra_attrs::Ptr{GLib._GSList{Ptr{Nothing}}}
    end
    mutable struct PangoAnalysis
        handle::Ptr{_PangoAnalysis}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAnalysis}}, box::PangoAnalysis) = begin
                convert(Ptr{_PangoAnalysis}, box.handle)
            end
        convert(::Type{PangoAnalysis}, p::Ptr{_PangoAnalysis}, owns = false) = begin
                PangoAnalysis(p, owns)
            end
        const PangoAnalysisLike = Union{Ref{_PangoAnalysis}, PangoAnalysis}
        convert(::Type{PangoAnalysisLike}, p, owns) = begin
                convert(PangoAnalysis, p, owns)
            end
    end
end
begin
    struct _PangoItem
        offset::Int32
        length::Int32
        num_chars::Int32
        analysis::_PangoAnalysis
    end
    mutable struct PangoItem <: GBoxed
        handle::Ptr{_PangoItem}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoItem) = begin
                    ccall(("pango_item_get_type", libpango), GType, ())
                end
            function PangoItem(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoItem}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoItem)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoItem}}, box::PangoItem) = begin
                convert(Ptr{_PangoItem}, box.handle)
            end
        convert(::Type{PangoItem}, p::Ptr{_PangoItem}, owns = false) = begin
                PangoItem(p, owns)
            end
        const PangoItemLike = Union{Ref{_PangoItem}, PangoItem}
        convert(::Type{PangoItemLike}, p, owns) = begin
                convert(PangoItem, p, owns)
            end
    end
end
begin
    struct _PangoGlyphVisAttr
        is_cluster_start::UInt32
        is_color::UInt32
    end
    mutable struct PangoGlyphVisAttr
        handle::Ptr{_PangoGlyphVisAttr}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoGlyphVisAttr}}, box::PangoGlyphVisAttr) = begin
                convert(Ptr{_PangoGlyphVisAttr}, box.handle)
            end
        convert(::Type{PangoGlyphVisAttr}, p::Ptr{_PangoGlyphVisAttr}, owns = false) = begin
                PangoGlyphVisAttr(p, owns)
            end
        const PangoGlyphVisAttrLike = Union{Ref{_PangoGlyphVisAttr}, PangoGlyphVisAttr}
        convert(::Type{PangoGlyphVisAttrLike}, p, owns) = begin
                convert(PangoGlyphVisAttr, p, owns)
            end
    end
end
begin
    struct _PangoGlyphGeometry
        width::Int32
        x_offset::Int32
        y_offset::Int32
    end
    mutable struct PangoGlyphGeometry
        handle::Ptr{_PangoGlyphGeometry}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoGlyphGeometry}}, box::PangoGlyphGeometry) = begin
                convert(Ptr{_PangoGlyphGeometry}, box.handle)
            end
        convert(::Type{PangoGlyphGeometry}, p::Ptr{_PangoGlyphGeometry}, owns = false) = begin
                PangoGlyphGeometry(p, owns)
            end
        const PangoGlyphGeometryLike = Union{Ref{_PangoGlyphGeometry}, PangoGlyphGeometry}
        convert(::Type{PangoGlyphGeometryLike}, p, owns) = begin
                convert(PangoGlyphGeometry, p, owns)
            end
    end
end
begin
    struct _PangoGlyphInfo
        glyph::UInt32
        geometry::_PangoGlyphGeometry
        attr::_PangoGlyphVisAttr
    end
    mutable struct PangoGlyphInfo
        handle::Ptr{_PangoGlyphInfo}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoGlyphInfo}}, box::PangoGlyphInfo) = begin
                convert(Ptr{_PangoGlyphInfo}, box.handle)
            end
        convert(::Type{PangoGlyphInfo}, p::Ptr{_PangoGlyphInfo}, owns = false) = begin
                PangoGlyphInfo(p, owns)
            end
        const PangoGlyphInfoLike = Union{Ref{_PangoGlyphInfo}, PangoGlyphInfo}
        convert(::Type{PangoGlyphInfoLike}, p, owns) = begin
                convert(PangoGlyphInfo, p, owns)
            end
    end
end
begin
    struct _PangoGlyphString
        num_glyphs::Int32
        glyphs::Ptr{_PangoGlyphInfo}
        log_clusters::Ptr{Int32}
        space::Int32
    end
    mutable struct PangoGlyphString <: GBoxed
        handle::Ptr{_PangoGlyphString}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoGlyphString) = begin
                    ccall(("pango_glyph_string_get_type", libpango), GType, ())
                end
            function PangoGlyphString(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoGlyphString}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoGlyphString)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoGlyphString}}, box::PangoGlyphString) = begin
                convert(Ptr{_PangoGlyphString}, box.handle)
            end
        convert(::Type{PangoGlyphString}, p::Ptr{_PangoGlyphString}, owns = false) = begin
                PangoGlyphString(p, owns)
            end
        const PangoGlyphStringLike = Union{Ref{_PangoGlyphString}, PangoGlyphString}
        convert(::Type{PangoGlyphStringLike}, p, owns) = begin
                convert(PangoGlyphString, p, owns)
            end
    end
end
begin
    struct _PangoGlyphItem
        item::Ptr{_PangoItem}
        glyphs::Ptr{_PangoGlyphString}
        y_offset::Int32
        start_x_offset::Int32
        end_x_offset::Int32
    end
    mutable struct PangoGlyphItem <: GBoxed
        handle::Ptr{_PangoGlyphItem}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoGlyphItem) = begin
                    ccall(("pango_glyph_item_get_type", libpango), GType, ())
                end
            function PangoGlyphItem(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoGlyphItem}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoGlyphItem)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoGlyphItem}}, box::PangoGlyphItem) = begin
                convert(Ptr{_PangoGlyphItem}, box.handle)
            end
        convert(::Type{PangoGlyphItem}, p::Ptr{_PangoGlyphItem}, owns = false) = begin
                PangoGlyphItem(p, owns)
            end
        const PangoGlyphItemLike = Union{Ref{_PangoGlyphItem}, PangoGlyphItem}
        convert(::Type{PangoGlyphItemLike}, p, owns) = begin
                convert(PangoGlyphItem, p, owns)
            end
    end
end
begin
    struct _PangoAttrColor
        attr::_PangoAttribute
        color::_PangoColor
    end
    mutable struct PangoAttrColor
        handle::Ptr{_PangoAttrColor}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrColor}}, box::PangoAttrColor) = begin
                convert(Ptr{_PangoAttrColor}, box.handle)
            end
        convert(::Type{PangoAttrColor}, p::Ptr{_PangoAttrColor}, owns = false) = begin
                PangoAttrColor(p, owns)
            end
        const PangoAttrColorLike = Union{Ref{_PangoAttrColor}, PangoAttrColor}
        convert(::Type{PangoAttrColorLike}, p, owns) = begin
                convert(PangoAttrColor, p, owns)
            end
    end
end
begin
    struct _PangoAttrFloat
        attr::_PangoAttribute
        value::Float64
    end
    mutable struct PangoAttrFloat
        handle::Ptr{_PangoAttrFloat}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrFloat}}, box::PangoAttrFloat) = begin
                convert(Ptr{_PangoAttrFloat}, box.handle)
            end
        convert(::Type{PangoAttrFloat}, p::Ptr{_PangoAttrFloat}, owns = false) = begin
                PangoAttrFloat(p, owns)
            end
        const PangoAttrFloatLike = Union{Ref{_PangoAttrFloat}, PangoAttrFloat}
        convert(::Type{PangoAttrFloatLike}, p, owns) = begin
                convert(PangoAttrFloat, p, owns)
            end
    end
end
begin
    struct _PangoAttrFontDesc
        attr::_PangoAttribute
        desc::Ptr{PangoFontDescription}
    end
    mutable struct PangoAttrFontDesc
        handle::Ptr{_PangoAttrFontDesc}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrFontDesc}}, box::PangoAttrFontDesc) = begin
                convert(Ptr{_PangoAttrFontDesc}, box.handle)
            end
        convert(::Type{PangoAttrFontDesc}, p::Ptr{_PangoAttrFontDesc}, owns = false) = begin
                PangoAttrFontDesc(p, owns)
            end
        const PangoAttrFontDescLike = Union{Ref{_PangoAttrFontDesc}, PangoAttrFontDesc}
        convert(::Type{PangoAttrFontDescLike}, p, owns) = begin
                convert(PangoAttrFontDesc, p, owns)
            end
    end
end
begin
    struct _PangoAttrFontFeatures
        attr::_PangoAttribute
        features::Cstring
    end
    mutable struct PangoAttrFontFeatures
        handle::Ptr{_PangoAttrFontFeatures}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrFontFeatures}}, box::PangoAttrFontFeatures) = begin
                convert(Ptr{_PangoAttrFontFeatures}, box.handle)
            end
        convert(::Type{PangoAttrFontFeatures}, p::Ptr{_PangoAttrFontFeatures}, owns = false) = begin
                PangoAttrFontFeatures(p, owns)
            end
        const PangoAttrFontFeaturesLike = Union{Ref{_PangoAttrFontFeatures}, PangoAttrFontFeatures}
        convert(::Type{PangoAttrFontFeaturesLike}, p, owns) = begin
                convert(PangoAttrFontFeatures, p, owns)
            end
    end
end
begin
    struct _PangoAttrInt
        attr::_PangoAttribute
        value::Int32
    end
    mutable struct PangoAttrInt
        handle::Ptr{_PangoAttrInt}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrInt}}, box::PangoAttrInt) = begin
                convert(Ptr{_PangoAttrInt}, box.handle)
            end
        convert(::Type{PangoAttrInt}, p::Ptr{_PangoAttrInt}, owns = false) = begin
                PangoAttrInt(p, owns)
            end
        const PangoAttrIntLike = Union{Ref{_PangoAttrInt}, PangoAttrInt}
        convert(::Type{PangoAttrIntLike}, p, owns) = begin
                convert(PangoAttrInt, p, owns)
            end
    end
end
begin
    mutable struct PangoAttrIterator <: GBoxed
        handle::Ptr{PangoAttrIterator}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoAttrIterator) = begin
                    ccall(("pango_attr_iterator_get_type", libpango), GType, ())
                end
            function PangoAttrIterator(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, PangoAttrIterator)
        end
    end
    const PangoAttrIteratorLike = PangoAttrIterator
end
begin
    struct _PangoAttrLanguage
        attr::_PangoAttribute
        value::Ptr{PangoLanguage}
    end
    mutable struct PangoAttrLanguage
        handle::Ptr{_PangoAttrLanguage}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrLanguage}}, box::PangoAttrLanguage) = begin
                convert(Ptr{_PangoAttrLanguage}, box.handle)
            end
        convert(::Type{PangoAttrLanguage}, p::Ptr{_PangoAttrLanguage}, owns = false) = begin
                PangoAttrLanguage(p, owns)
            end
        const PangoAttrLanguageLike = Union{Ref{_PangoAttrLanguage}, PangoAttrLanguage}
        convert(::Type{PangoAttrLanguageLike}, p, owns) = begin
                convert(PangoAttrLanguage, p, owns)
            end
    end
end
begin
    mutable struct PangoAttrList <: GBoxed
        handle::Ptr{PangoAttrList}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoAttrList) = begin
                    ccall(("pango_attr_list_get_type", libpango), GType, ())
                end
            function PangoAttrList(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, PangoAttrList)
        end
    end
    const PangoAttrListLike = PangoAttrList
end
begin
    struct _PangoAttrShape
        attr::_PangoAttribute
        ink_rect::_PangoRectangle
        logical_rect::_PangoRectangle
        data::Ptr{Nothing}
        copy_func::Ptr{Cvoid}
        destroy_func::Ptr{Cvoid}
    end
    mutable struct PangoAttrShape
        handle::Ptr{_PangoAttrShape}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrShape}}, box::PangoAttrShape) = begin
                convert(Ptr{_PangoAttrShape}, box.handle)
            end
        convert(::Type{PangoAttrShape}, p::Ptr{_PangoAttrShape}, owns = false) = begin
                PangoAttrShape(p, owns)
            end
        const PangoAttrShapeLike = Union{Ref{_PangoAttrShape}, PangoAttrShape}
        convert(::Type{PangoAttrShapeLike}, p, owns) = begin
                convert(PangoAttrShape, p, owns)
            end
    end
end
begin
    struct _PangoAttrSize
        attr::_PangoAttribute
        size::Int32
        absolute::UInt32
    end
    mutable struct PangoAttrSize
        handle::Ptr{_PangoAttrSize}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrSize}}, box::PangoAttrSize) = begin
                convert(Ptr{_PangoAttrSize}, box.handle)
            end
        convert(::Type{PangoAttrSize}, p::Ptr{_PangoAttrSize}, owns = false) = begin
                PangoAttrSize(p, owns)
            end
        const PangoAttrSizeLike = Union{Ref{_PangoAttrSize}, PangoAttrSize}
        convert(::Type{PangoAttrSizeLike}, p, owns) = begin
                convert(PangoAttrSize, p, owns)
            end
    end
end
begin
    struct _PangoAttrString
        attr::_PangoAttribute
        value::Cstring
    end
    mutable struct PangoAttrString
        handle::Ptr{_PangoAttrString}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoAttrString}}, box::PangoAttrString) = begin
                convert(Ptr{_PangoAttrString}, box.handle)
            end
        convert(::Type{PangoAttrString}, p::Ptr{_PangoAttrString}, owns = false) = begin
                PangoAttrString(p, owns)
            end
        const PangoAttrStringLike = Union{Ref{_PangoAttrString}, PangoAttrString}
        convert(::Type{PangoAttrStringLike}, p, owns) = begin
                convert(PangoAttrString, p, owns)
            end
    end
end
begin
    struct _PangoFontMetrics
        ref_count::UInt32
        ascent::Int32
        descent::Int32
        height::Int32
        approximate_char_width::Int32
        approximate_digit_width::Int32
        underline_position::Int32
        underline_thickness::Int32
        strikethrough_position::Int32
        strikethrough_thickness::Int32
    end
    mutable struct PangoFontMetrics <: GBoxed
        handle::Ptr{_PangoFontMetrics}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoFontMetrics) = begin
                    ccall(("pango_font_metrics_get_type", libpango), GType, ())
                end
            function PangoFontMetrics(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoFontMetrics}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoFontMetrics)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoFontMetrics}}, box::PangoFontMetrics) = begin
                convert(Ptr{_PangoFontMetrics}, box.handle)
            end
        convert(::Type{PangoFontMetrics}, p::Ptr{_PangoFontMetrics}, owns = false) = begin
                PangoFontMetrics(p, owns)
            end
        const PangoFontMetricsLike = Union{Ref{_PangoFontMetrics}, PangoFontMetrics}
        convert(::Type{PangoFontMetricsLike}, p, owns) = begin
                convert(PangoFontMetrics, p, owns)
            end
    end
end
begin
    struct _PangoGlyphItemIter
        glyph_item::Ptr{_PangoGlyphItem}
        text::Cstring
        start_glyph::Int32
        start_index::Int32
        start_char::Int32
        end_glyph::Int32
        end_index::Int32
        end_char::Int32
    end
    mutable struct PangoGlyphItemIter <: GBoxed
        handle::Ptr{_PangoGlyphItemIter}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoGlyphItemIter) = begin
                    ccall(("pango_glyph_item_iter_get_type", libpango), GType, ())
                end
            function PangoGlyphItemIter(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoGlyphItemIter}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoGlyphItemIter)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoGlyphItemIter}}, box::PangoGlyphItemIter) = begin
                convert(Ptr{_PangoGlyphItemIter}, box.handle)
            end
        convert(::Type{PangoGlyphItemIter}, p::Ptr{_PangoGlyphItemIter}, owns = false) = begin
                PangoGlyphItemIter(p, owns)
            end
        const PangoGlyphItemIterLike = Union{Ref{_PangoGlyphItemIter}, PangoGlyphItemIter}
        convert(::Type{PangoGlyphItemIterLike}, p, owns) = begin
                convert(PangoGlyphItemIter, p, owns)
            end
    end
end
begin
    mutable struct PangoLayoutIter <: GBoxed
        handle::Ptr{PangoLayoutIter}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoLayoutIter) = begin
                    ccall(("pango_layout_iter_get_type", libpango), GType, ())
                end
            function PangoLayoutIter(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, PangoLayoutIter)
        end
    end
    const PangoLayoutIterLike = PangoLayoutIter
end
begin
    struct _PangoLayoutLine
        layout::Ptr{GObject}
        start_index::Int32
        length::Int32
        runs::Ptr{GLib._GSList{_PangoGlyphItem}}
        is_paragraph_start::UInt32
        resolved_dir::UInt32
    end
    mutable struct PangoLayoutLine <: GBoxed
        handle::Ptr{_PangoLayoutLine}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoLayoutLine) = begin
                    ccall(("pango_layout_line_get_type", libpango), GType, ())
                end
            function PangoLayoutLine(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoLayoutLine}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoLayoutLine)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoLayoutLine}}, box::PangoLayoutLine) = begin
                convert(Ptr{_PangoLayoutLine}, box.handle)
            end
        convert(::Type{PangoLayoutLine}, p::Ptr{_PangoLayoutLine}, owns = false) = begin
                PangoLayoutLine(p, owns)
            end
        const PangoLayoutLineLike = Union{Ref{_PangoLayoutLine}, PangoLayoutLine}
        convert(::Type{PangoLayoutLineLike}, p, owns) = begin
                convert(PangoLayoutLine, p, owns)
            end
    end
end
begin
    struct _PangoLogAttr
        is_line_break::UInt32
        is_mandatory_break::UInt32
        is_char_break::UInt32
        is_white::UInt32
        is_cursor_position::UInt32
        is_word_start::UInt32
        is_word_end::UInt32
        is_sentence_boundary::UInt32
        is_sentence_start::UInt32
        is_sentence_end::UInt32
        backspace_deletes_character::UInt32
        is_expandable_space::UInt32
        is_word_boundary::UInt32
        break_inserts_hyphen::UInt32
        break_removes_preceding::UInt32
        reserved::UInt32
    end
    mutable struct PangoLogAttr
        handle::Ptr{_PangoLogAttr}
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoLogAttr}}, box::PangoLogAttr) = begin
                convert(Ptr{_PangoLogAttr}, box.handle)
            end
        convert(::Type{PangoLogAttr}, p::Ptr{_PangoLogAttr}, owns = false) = begin
                PangoLogAttr(p, owns)
            end
        const PangoLogAttrLike = Union{Ref{_PangoLogAttr}, PangoLogAttr}
        convert(::Type{PangoLogAttrLike}, p, owns) = begin
                convert(PangoLogAttr, p, owns)
            end
    end
end
begin
    struct _PangoMatrix
        xx::Float64
        xy::Float64
        yx::Float64
        yy::Float64
        x0::Float64
        y0::Float64
    end
    mutable struct PangoMatrix <: GBoxed
        handle::Ptr{_PangoMatrix}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoMatrix) = begin
                    ccall(("pango_matrix_get_type", libpango), GType, ())
                end
            function PangoMatrix(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _PangoMatrix}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, PangoMatrix)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_PangoMatrix}}, box::PangoMatrix) = begin
                convert(Ptr{_PangoMatrix}, box.handle)
            end
        convert(::Type{PangoMatrix}, p::Ptr{_PangoMatrix}, owns = false) = begin
                PangoMatrix(p, owns)
            end
        const PangoMatrixLike = Union{Ref{_PangoMatrix}, PangoMatrix}
        convert(::Type{PangoMatrixLike}, p, owns) = begin
                convert(PangoMatrix, p, owns)
            end
    end
end
begin
    mutable struct PangoScriptIter <: GBoxed
        handle::Ptr{PangoScriptIter}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoScriptIter) = begin
                    ccall(("pango_script_iter_get_type", libpango), GType, ())
                end
            function PangoScriptIter(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, PangoScriptIter)
        end
    end
    const PangoScriptIterLike = PangoScriptIter
end
begin
    mutable struct PangoTabArray <: GBoxed
        handle::Ptr{PangoTabArray}
        begin
            (GLib.g_type(::Type{T}) where T <: PangoTabArray) = begin
                    ccall(("pango_tab_array_get_type", libpango), GType, ())
                end
            function PangoTabArray(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, PangoTabArray)
        end
    end
    const PangoTabArrayLike = PangoTabArray
end
gboxed_cache_init() = begin
        append!(GLib.gboxed_types, gboxed_types)
    end
const gtype_wrapper_cache = Dict{Symbol, Type}()
begin
    abstract type PangoContext <: GObject end
    mutable struct PangoContextLeaf <: PangoContext
        handle::Ptr{GObject}
        function PangoContextLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoContextLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoContext] = PangoContextLeaf
    (GLib.g_type(::Type{T}) where T <: PangoContext) = begin
            ccall(("pango_context_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoContext})
        signalnames(supertype(PangoContext))
    end
end
begin
    abstract type PangoCoverage <: GObject end
    mutable struct PangoCoverageLeaf <: PangoCoverage
        handle::Ptr{GObject}
        function PangoCoverageLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoCoverageLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoCoverage] = PangoCoverageLeaf
    (GLib.g_type(::Type{T}) where T <: PangoCoverage) = begin
            ccall(("pango_coverage_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoCoverage})
        signalnames(supertype(PangoCoverage))
    end
end
begin
    abstract type PangoFont <: GObject end
    mutable struct PangoFontLeaf <: PangoFont
        handle::Ptr{GObject}
        function PangoFontLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoFontLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoFont] = PangoFontLeaf
    (GLib.g_type(::Type{T}) where T <: PangoFont) = begin
            ccall(("pango_font_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoFont})
        signalnames(supertype(PangoFont))
    end
end
begin
    abstract type PangoFontFace <: GObject end
    mutable struct PangoFontFaceLeaf <: PangoFontFace
        handle::Ptr{GObject}
        function PangoFontFaceLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoFontFaceLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoFontFace] = PangoFontFaceLeaf
    (GLib.g_type(::Type{T}) where T <: PangoFontFace) = begin
            ccall(("pango_font_face_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoFontFace})
        signalnames(supertype(PangoFontFace))
    end
end
begin
    abstract type PangoFontFamily <: GObject end
    mutable struct PangoFontFamilyLeaf <: PangoFontFamily
        handle::Ptr{GObject}
        function PangoFontFamilyLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoFontFamilyLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoFontFamily] = PangoFontFamilyLeaf
    (GLib.g_type(::Type{T}) where T <: PangoFontFamily) = begin
            ccall(("pango_font_family_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoFontFamily})
        vcat([:items_changed], signalnames(supertype(PangoFontFamily)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: PangoFontFamily
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: PangoFontFamily
            Tuple(eval.((d[name])[2]))
        end
    end
end
begin
    abstract type PangoFontMap <: GObject end
    mutable struct PangoFontMapLeaf <: PangoFontMap
        handle::Ptr{GObject}
        function PangoFontMapLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoFontMapLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoFontMap] = PangoFontMapLeaf
    (GLib.g_type(::Type{T}) where T <: PangoFontMap) = begin
            ccall(("pango_font_map_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoFontMap})
        vcat([:items_changed], signalnames(supertype(PangoFontMap)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: PangoFontMap
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: PangoFontMap
            Tuple(eval.((d[name])[2]))
        end
    end
end
begin
    abstract type PangoFontset <: GObject end
    mutable struct PangoFontsetLeaf <: PangoFontset
        handle::Ptr{GObject}
        function PangoFontsetLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoFontsetLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoFontset] = PangoFontsetLeaf
    (GLib.g_type(::Type{T}) where T <: PangoFontset) = begin
            ccall(("pango_fontset_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoFontset})
        signalnames(supertype(PangoFontset))
    end
end
begin
    abstract type PangoFontsetSimple <: PangoFontset end
    mutable struct PangoFontsetSimpleLeaf <: PangoFontsetSimple
        handle::Ptr{GObject}
        function PangoFontsetSimpleLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoFontsetSimpleLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoFontsetSimple] = PangoFontsetSimpleLeaf
    (GLib.g_type(::Type{T}) where T <: PangoFontsetSimple) = begin
            ccall(("pango_fontset_simple_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoFontsetSimple})
        signalnames(supertype(PangoFontsetSimple))
    end
end
begin
    abstract type PangoLayout <: GObject end
    mutable struct PangoLayoutLeaf <: PangoLayout
        handle::Ptr{GObject}
        function PangoLayoutLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoLayoutLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoLayout] = PangoLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: PangoLayout) = begin
            ccall(("pango_layout_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoLayout})
        signalnames(supertype(PangoLayout))
    end
end
begin
    abstract type PangoRenderer <: GObject end
    mutable struct PangoRendererLeaf <: PangoRenderer
        handle::Ptr{GObject}
        function PangoRendererLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct PangoRendererLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:PangoRenderer] = PangoRendererLeaf
    (GLib.g_type(::Type{T}) where T <: PangoRenderer) = begin
            ccall(("pango_renderer_get_type", libpango), GType, ())
        end
end
begin
    function GLib.signalnames(::Type{PangoRenderer})
        signalnames(supertype(PangoRenderer))
    end
end
begin
    gtype_wrapper_cache_init() = begin
            merge!(GLib.gtype_wrappers, gtype_wrapper_cache)
        end
end
function PangoContext()
    G_.Context_new()
end
function PangoCoverage()
    G_.Coverage_new()
end
function PangoFontsetSimple(_language::PangoLanguage)
    G_.FontsetSimple_new(_language)
end
function PangoLayout(_context::PangoContext)
    G_.Layout_new(_context)
end
function PangoFontDescription()
    G_.FontDescription_new()
end
function PangoItem()
    G_.Item_new()
end
function PangoGlyphString()
    G_.GlyphString_new()
end
function PangoAttrList()
    G_.AttrList_new()
end
function PangoScriptIter(_text::Union{AbstractString, Symbol}, _length::Integer)
    G_.ScriptIter_new(_text, _length)
end
function PangoTabArray(_initial_size::Integer, _positions_in_pixels::Bool)
    G_.TabArray_new(_initial_size, _positions_in_pixels)
end
function on_items_changed(f, object::PangoFontFamily, user_data = object, after = false)
    GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
end
function on_items_changed(f, object::PangoFontMap, user_data = object, after = false)
    GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
end
function PangoAttrDataCopyFunc(user_data)
    f = user_data
    ret = f()
    convert(Ptr{Nothing}, ret)
end
function PangoAttrFilterFunc(attribute, user_data)
    attribute = convert(PangoAttributeLike, attribute, false)
    f = user_data
    ret = f(attribute)
    convert(Cint, ret)
end
function PangoFontsetForeachFunc(fontset, font, user_data)
    fontset = convert(PangoFontset, fontset, false)
    font = convert(PangoFont, font, false)
    f = user_data
    ret = f(fontset, font)
    convert(Cint, ret)
end
export PangoLanguage, PangoColor, _PangoColor, PangoColorLike, PangoAttrClass, _PangoAttrClass, PangoAttrClassLike, PangoRectangle, _PangoRectangle, PangoRectangleLike, PangoFontDescription, PangoAttribute, _PangoAttribute, PangoAttributeLike, PangoAnalysis, _PangoAnalysis, PangoAnalysisLike, PangoItem, _PangoItem, PangoItemLike, PangoGlyphVisAttr, _PangoGlyphVisAttr, PangoGlyphVisAttrLike, PangoGlyphGeometry, _PangoGlyphGeometry, PangoGlyphGeometryLike, PangoGlyphInfo, _PangoGlyphInfo, PangoGlyphInfoLike, PangoGlyphString, _PangoGlyphString, PangoGlyphStringLike, PangoGlyphItem, _PangoGlyphItem, PangoGlyphItemLike, PangoAttrColor, PangoAttrColorLike, _PangoAttrColor, PangoAttrFloat, PangoAttrFloatLike, _PangoAttrFloat, PangoAttrFontDesc, PangoAttrFontDescLike, _PangoAttrFontDesc, PangoAttrFontFeatures, PangoAttrFontFeaturesLike, _PangoAttrFontFeatures, PangoAttrInt, PangoAttrIntLike, _PangoAttrInt, PangoAttrIterator, PangoAttrLanguage, PangoAttrLanguageLike, _PangoAttrLanguage, PangoAttrList, PangoAttrShape, PangoAttrShapeLike, _PangoAttrShape, PangoAttrSize, PangoAttrSizeLike, _PangoAttrSize, PangoAttrString, PangoAttrStringLike, _PangoAttrString, PangoFontMetrics, PangoFontMetricsLike, _PangoFontMetrics, PangoGlyphItemIter, PangoGlyphItemIterLike, _PangoGlyphItemIter, PangoLayoutIter, PangoLayoutLine, PangoLayoutLineLike, _PangoLayoutLine, PangoLogAttr, PangoLogAttrLike, _PangoLogAttr, PangoMatrix, PangoMatrixLike, _PangoMatrix, PangoScriptIter, PangoTabArray, PangoContext, PangoContextLeaf, PangoCoverage, PangoCoverageLeaf, PangoFont, PangoFontFace, PangoFontFamily, PangoFontMap, PangoFontset, PangoFontsetSimple, PangoFontsetSimpleLeaf, PangoLayout, PangoLayoutLeaf, PangoRenderer, PangoAttrDataCopyFunc, PangoAttrFilterFunc, PangoFontsetForeachFunc
