quote
$(Expr(:toplevel, quote
    gboxed_types = Any[]
    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
    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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoColor)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoColor}}, box::PangoColor) = begin
                convert(Ptr{_PangoColor}, box.handle)
            end
    end
    begin
        struct _PangoAttrClass
            type::UInt32
            copy::Ptr{Cvoid}
            destroy::Ptr{Cvoid}
            equal::Ptr{Cvoid}
        end
        mutable struct PangoAttrClass
            handle::Ptr{_PangoAttrClass}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrClass}}, box::PangoAttrClass) = begin
                convert(Ptr{_PangoAttrClass}, box.handle)
            end
    end
    begin
        struct _PangoRectangle
            x::Int32
            y::Int32
            width::Int32
            height::Int32
        end
        mutable struct PangoRectangle
            handle::Ptr{_PangoRectangle}
        end
        unsafe_convert(::Type{Ptr{_PangoRectangle}}, box::PangoRectangle) = begin
                convert(Ptr{_PangoRectangle}, box.handle)
            end
    end
    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
    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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoAttribute)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoAttribute}}, box::PangoAttribute) = begin
                convert(Ptr{_PangoAttribute}, box.handle)
            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
        unsafe_convert(::Type{Ptr{_PangoAnalysis}}, box::PangoAnalysis) = begin
                convert(Ptr{_PangoAnalysis}, box.handle)
            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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoItem)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoItem}}, box::PangoItem) = begin
                convert(Ptr{_PangoItem}, box.handle)
            end
    end
    begin
        struct _PangoGlyphVisAttr
            is_cluster_start::UInt32
            is_color::UInt32
        end
        mutable struct PangoGlyphVisAttr
            handle::Ptr{_PangoGlyphVisAttr}
        end
        unsafe_convert(::Type{Ptr{_PangoGlyphVisAttr}}, box::PangoGlyphVisAttr) = begin
                convert(Ptr{_PangoGlyphVisAttr}, box.handle)
            end
    end
    begin
        struct _PangoGlyphGeometry
            width::Int32
            x_offset::Int32
            y_offset::Int32
        end
        mutable struct PangoGlyphGeometry
            handle::Ptr{_PangoGlyphGeometry}
        end
        unsafe_convert(::Type{Ptr{_PangoGlyphGeometry}}, box::PangoGlyphGeometry) = begin
                convert(Ptr{_PangoGlyphGeometry}, box.handle)
            end
    end
    begin
        struct _PangoGlyphInfo
            glyph::UInt32
            geometry::_PangoGlyphGeometry
            attr::_PangoGlyphVisAttr
        end
        mutable struct PangoGlyphInfo
            handle::Ptr{_PangoGlyphInfo}
        end
        unsafe_convert(::Type{Ptr{_PangoGlyphInfo}}, box::PangoGlyphInfo) = begin
                convert(Ptr{_PangoGlyphInfo}, box.handle)
            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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoGlyphString)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoGlyphString}}, box::PangoGlyphString) = begin
                convert(Ptr{_PangoGlyphString}, box.handle)
            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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoGlyphItem)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoGlyphItem}}, box::PangoGlyphItem) = begin
                convert(Ptr{_PangoGlyphItem}, box.handle)
            end
    end
    function PangoFontDescription()
        G_.FontDescription_new()
    end
    function PangoItem()
        G_.Item_new()
    end
    function PangoGlyphString()
        G_.GlyphString_new()
    end
    begin
        struct _PangoAttrColor
            attr::_PangoAttribute
            color::_PangoColor
        end
        mutable struct PangoAttrColor
            handle::Ptr{_PangoAttrColor}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrColor}}, box::PangoAttrColor) = begin
                convert(Ptr{_PangoAttrColor}, box.handle)
            end
    end
    begin
        struct _PangoAttrFloat
            attr::_PangoAttribute
            value::Float64
        end
        mutable struct PangoAttrFloat
            handle::Ptr{_PangoAttrFloat}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrFloat}}, box::PangoAttrFloat) = begin
                convert(Ptr{_PangoAttrFloat}, box.handle)
            end
    end
    begin
        struct _PangoAttrFontDesc
            attr::_PangoAttribute
            desc::Ptr{PangoFontDescription}
        end
        mutable struct PangoAttrFontDesc
            handle::Ptr{_PangoAttrFontDesc}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrFontDesc}}, box::PangoAttrFontDesc) = begin
                convert(Ptr{_PangoAttrFontDesc}, box.handle)
            end
    end
    begin
        struct _PangoAttrFontFeatures
            attr::_PangoAttribute
            features::Cstring
        end
        mutable struct PangoAttrFontFeatures
            handle::Ptr{_PangoAttrFontFeatures}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrFontFeatures}}, box::PangoAttrFontFeatures) = begin
                convert(Ptr{_PangoAttrFontFeatures}, box.handle)
            end
    end
    begin
        struct _PangoAttrInt
            attr::_PangoAttribute
            value::Int32
        end
        mutable struct PangoAttrInt
            handle::Ptr{_PangoAttrInt}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrInt}}, box::PangoAttrInt) = begin
                convert(Ptr{_PangoAttrInt}, box.handle)
            end
    end
    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
    begin
        struct _PangoAttrLanguage
            attr::_PangoAttribute
            value::Ptr{PangoLanguage}
        end
        mutable struct PangoAttrLanguage
            handle::Ptr{_PangoAttrLanguage}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrLanguage}}, box::PangoAttrLanguage) = begin
                convert(Ptr{_PangoAttrLanguage}, box.handle)
            end
    end
    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
    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
        unsafe_convert(::Type{Ptr{_PangoAttrShape}}, box::PangoAttrShape) = begin
                convert(Ptr{_PangoAttrShape}, box.handle)
            end
    end
    begin
        struct _PangoAttrSize
            attr::_PangoAttribute
            size::Int32
            absolute::UInt32
        end
        mutable struct PangoAttrSize
            handle::Ptr{_PangoAttrSize}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrSize}}, box::PangoAttrSize) = begin
                convert(Ptr{_PangoAttrSize}, box.handle)
            end
    end
    begin
        struct _PangoAttrString
            attr::_PangoAttribute
            value::Cstring
        end
        mutable struct PangoAttrString
            handle::Ptr{_PangoAttrString}
        end
        unsafe_convert(::Type{Ptr{_PangoAttrString}}, box::PangoAttrString) = begin
                convert(Ptr{_PangoAttrString}, box.handle)
            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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoFontMetrics)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoFontMetrics}}, box::PangoFontMetrics) = begin
                convert(Ptr{_PangoFontMetrics}, box.handle)
            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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoGlyphItemIter)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoGlyphItemIter}}, box::PangoGlyphItemIter) = begin
                convert(Ptr{_PangoGlyphItemIter}, box.handle)
            end
    end
    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
    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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoLayoutLine)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoLayoutLine}}, box::PangoLayoutLine) = begin
                convert(Ptr{_PangoLayoutLine}, box.handle)
            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
        unsafe_convert(::Type{Ptr{_PangoLogAttr}}, box::PangoLogAttr) = begin
                convert(Ptr{_PangoLogAttr}, box.handle)
            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 <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, PangoMatrix)
            end
        end
        unsafe_convert(::Type{Ptr{_PangoMatrix}}, box::PangoMatrix) = begin
                convert(Ptr{_PangoMatrix}, box.handle)
            end
    end
    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
    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
    gboxed_cache_init() = begin
            append!(GLib.gboxed_types, gboxed_types)
        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
    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 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(Union{PangoAttribute, Ref{_PangoAttribute}}, 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, PangoAttrClass, _PangoAttrClass, PangoRectangle, _PangoRectangle, PangoFontDescription, PangoAttribute, _PangoAttribute, PangoAnalysis, _PangoAnalysis, PangoItem, _PangoItem, PangoGlyphVisAttr, _PangoGlyphVisAttr, PangoGlyphGeometry, _PangoGlyphGeometry, PangoGlyphInfo, _PangoGlyphInfo, PangoGlyphString, _PangoGlyphString, PangoGlyphItem, _PangoGlyphItem, PangoAttrColor, _PangoAttrColor, PangoAttrFloat, _PangoAttrFloat, PangoAttrFontDesc, _PangoAttrFontDesc, PangoAttrFontFeatures, _PangoAttrFontFeatures, PangoAttrInt, _PangoAttrInt, PangoAttrIterator, PangoAttrLanguage, _PangoAttrLanguage, PangoAttrList, PangoAttrShape, _PangoAttrShape, PangoAttrSize, _PangoAttrSize, PangoAttrString, _PangoAttrString, PangoFontMetrics, _PangoFontMetrics, PangoGlyphItemIter, _PangoGlyphItemIter, PangoLayoutIter, PangoLayoutLine, _PangoLayoutLine, PangoLogAttr, _PangoLogAttr, PangoMatrix, _PangoMatrix, PangoScriptIter, PangoTabArray, PangoContext, PangoContextLeaf, PangoCoverage, PangoCoverageLeaf, PangoFont, PangoFontFace, PangoFontFamily, PangoFontMap, PangoFontset, PangoFontsetSimple, PangoFontsetSimpleLeaf, PangoLayout, PangoLayoutLeaf, PangoRenderer, PangoAttrDataCopyFunc, PangoAttrFilterFunc, PangoFontsetForeachFunc
end))
end
