pub const ext = @import("ext.zig");
const gee = @This();

const std = @import("std");
const compat = @import("compat");
const gio = @import("gio2");
const gobject = @import("gobject2");
const glib = @import("glib2");
const gmodule = @import("gmodule2");
pub const AbstractBidirList = extern struct {
    pub const Parent = gee.AbstractList;
    pub const Implements = [_]type{gee.BidirList};
    pub const Class = gee.AbstractBidirListClass;
    f_parent_instance: gee.AbstractList,
    f_priv: ?*gee.AbstractBidirListPrivate,

    pub const virtual_methods = struct {
        pub const bidir_list_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirListIterator {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_bidir_list_iterator.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirListIterator) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_bidir_list_iterator = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirList {
                return gobject.ext.as(AbstractBidirList.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractBidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirList) void {
                gobject.ext.as(AbstractBidirList.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.BidirList;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_bidir_list_bidir_list_iterator(p_self: *AbstractBidirList) *gee.BidirListIterator;
    pub const bidirListIterator = gee_abstract_bidir_list_bidir_list_iterator;

    extern fn gee_abstract_bidir_list_get_read_only_view(p_self: *AbstractBidirList) *gee.BidirList;
    pub const getReadOnlyView = gee_abstract_bidir_list_get_read_only_view;

    extern fn gee_abstract_bidir_list_get_type() usize;
    pub const getGObjectType = gee_abstract_bidir_list_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractBidirList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractBidirList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractBidirList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirSortedSet = extern struct {
    pub const Parent = gee.AbstractSortedSet;
    pub const Implements = [_]type{gee.BidirSortedSet};
    pub const Class = gee.AbstractBidirSortedSetClass;
    f_parent_instance: gee.AbstractSortedSet,
    f_priv: ?*gee.AbstractBidirSortedSetPrivate,

    pub const virtual_methods = struct {
        pub const bidir_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirIterator {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_bidir_iterator.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirIterator) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_bidir_iterator = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirSortedSet {
                return gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractBidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirSortedSet) void {
                gobject.ext.as(AbstractBidirSortedSet.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.BidirSortedSet;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_bidir_sorted_set_bidir_iterator(p_self: *AbstractBidirSortedSet) *gee.BidirIterator;
    pub const bidirIterator = gee_abstract_bidir_sorted_set_bidir_iterator;

    extern fn gee_abstract_bidir_sorted_set_get_read_only_view(p_self: *AbstractBidirSortedSet) *gee.BidirSortedSet;
    pub const getReadOnlyView = gee_abstract_bidir_sorted_set_get_read_only_view;

    extern fn gee_abstract_bidir_sorted_set_get_type() usize;
    pub const getGObjectType = gee_abstract_bidir_sorted_set_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractBidirSortedSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractBidirSortedSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractBidirSortedSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirSortedMap = extern struct {
    pub const Parent = gee.AbstractSortedMap;
    pub const Implements = [_]type{gee.BidirSortedMap};
    pub const Class = gee.AbstractBidirSortedMapClass;
    f_parent_instance: gee.AbstractSortedMap,
    f_priv: ?*gee.AbstractBidirSortedMapPrivate,

    pub const virtual_methods = struct {
        pub const bidir_map_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirMapIterator {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_bidir_map_iterator.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirMapIterator) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_bidir_map_iterator = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirSortedMap {
                return gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractBidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirSortedMap) void {
                gobject.ext.as(AbstractBidirSortedMap.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.BidirSortedMap;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_bidir_sorted_map_bidir_map_iterator(p_self: *AbstractBidirSortedMap) *gee.BidirMapIterator;
    pub const bidirMapIterator = gee_abstract_bidir_sorted_map_bidir_map_iterator;

    extern fn gee_abstract_bidir_sorted_map_get_read_only_view(p_self: *AbstractBidirSortedMap) *gee.BidirSortedMap;
    pub const getReadOnlyView = gee_abstract_bidir_sorted_map_get_read_only_view;

    extern fn gee_abstract_bidir_sorted_map_get_type() usize;
    pub const getGObjectType = gee_abstract_bidir_sorted_map_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractBidirSortedMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractBidirSortedMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractBidirSortedMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractCollection = extern struct {
    pub const Parent = gobject.Object;
    pub const Implements = [_]type{ gee.Traversable, gee.Iterable, gee.Collection };
    pub const Class = gee.AbstractCollectionClass;
    f_parent_instance: gobject.Object,
    f_priv: ?*gee.AbstractCollectionPrivate,

    pub const virtual_methods = struct {
        pub const contains = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_contains.?(gobject.ext.as(AbstractCollection, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_contains = @ptrCast(p_implementation);
            }
        };

        pub const add = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_add.?(gobject.ext.as(AbstractCollection, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_add = @ptrCast(p_implementation);
            }
        };

        pub const remove = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_remove.?(gobject.ext.as(AbstractCollection, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_remove = @ptrCast(p_implementation);
            }
        };

        pub const clear = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_clear.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_clear = @ptrCast(p_implementation);
            }
        };

        pub const iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Iterator {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_iterator.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_iterator = @ptrCast(p_implementation);
            }
        };

        pub const foreach = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_foreach.?(gobject.ext.as(AbstractCollection, p_self), p_f, p_f_target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_foreach = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_size = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_get_size.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_get_size = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_get_read_only.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Collection {
                return gobject.ext.as(AbstractCollection.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractCollection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Collection) void {
                gobject.ext.as(AbstractCollection.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const size = struct {
            pub const name = "size";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.Collection;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_collection_contains(p_self: *AbstractCollection, p_item: ?*anyopaque) c_int;
    pub const contains = gee_abstract_collection_contains;

    extern fn gee_abstract_collection_add(p_self: *AbstractCollection, p_item: ?*anyopaque) c_int;
    pub const add = gee_abstract_collection_add;

    extern fn gee_abstract_collection_remove(p_self: *AbstractCollection, p_item: ?*anyopaque) c_int;
    pub const remove = gee_abstract_collection_remove;

    extern fn gee_abstract_collection_clear(p_self: *AbstractCollection) void;
    pub const clear = gee_abstract_collection_clear;

    extern fn gee_abstract_collection_iterator(p_self: *AbstractCollection) *gee.Iterator;
    pub const iterator = gee_abstract_collection_iterator;

    extern fn gee_abstract_collection_foreach(p_self: *AbstractCollection, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) c_int;
    pub const foreach = gee_abstract_collection_foreach;

    extern fn gee_abstract_collection_get_size(p_self: *AbstractCollection) c_int;
    pub const getSize = gee_abstract_collection_get_size;

    extern fn gee_abstract_collection_get_read_only(p_self: *AbstractCollection) c_int;
    pub const getReadOnly = gee_abstract_collection_get_read_only;

    extern fn gee_abstract_collection_get_read_only_view(p_self: *AbstractCollection) *gee.Collection;
    pub const getReadOnlyView = gee_abstract_collection_get_read_only_view;

    extern fn gee_abstract_collection_get_type() usize;
    pub const getGObjectType = gee_abstract_collection_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractCollection) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractCollection) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractCollection, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractList = extern struct {
    pub const Parent = gee.AbstractCollection;
    pub const Implements = [_]type{gee.List};
    pub const Class = gee.AbstractListClass;
    f_parent_instance: gee.AbstractCollection,
    f_priv: ?*gee.AbstractListPrivate,

    pub const virtual_methods = struct {
        pub const list_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.ListIterator {
                return gobject.ext.as(AbstractList.Class, p_class).f_list_iterator.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.ListIterator) void {
                gobject.ext.as(AbstractList.Class, p_class).f_list_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) ?*anyopaque {
                return gobject.ext.as(AbstractList.Class, p_class).f_get.?(gobject.ext.as(AbstractList, p_self), p_index);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractList.Class, p_class).f_get = @ptrCast(p_implementation);
            }
        };

        pub const set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_set.?(gobject.ext.as(AbstractList, p_self), p_index, p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_set = @ptrCast(p_implementation);
            }
        };

        pub const index_of = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractList.Class, p_class).f_index_of.?(gobject.ext.as(AbstractList, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractList.Class, p_class).f_index_of = @ptrCast(p_implementation);
            }
        };

        pub const insert = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_insert.?(gobject.ext.as(AbstractList, p_self), p_index, p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_insert = @ptrCast(p_implementation);
            }
        };

        pub const remove_at = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) ?*anyopaque {
                return gobject.ext.as(AbstractList.Class, p_class).f_remove_at.?(gobject.ext.as(AbstractList, p_self), p_index);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractList.Class, p_class).f_remove_at = @ptrCast(p_implementation);
            }
        };

        pub const slice = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_start: c_int, p_stop: c_int) ?*gee.List {
                return gobject.ext.as(AbstractList.Class, p_class).f_slice.?(gobject.ext.as(AbstractList, p_self), p_start, p_stop);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_start: c_int, p_stop: c_int) callconv(.c) ?*gee.List) void {
                gobject.ext.as(AbstractList.Class, p_class).f_slice = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractList.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractList.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.List {
                return gobject.ext.as(AbstractList.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.List) void {
                gobject.ext.as(AbstractList.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.List;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_list_list_iterator(p_self: *AbstractList) *gee.ListIterator;
    pub const listIterator = gee_abstract_list_list_iterator;

    extern fn gee_abstract_list_get(p_self: *AbstractList, p_index: c_int) ?*anyopaque;
    pub const get = gee_abstract_list_get;

    extern fn gee_abstract_list_set(p_self: *AbstractList, p_index: c_int, p_item: ?*anyopaque) void;
    pub const set = gee_abstract_list_set;

    extern fn gee_abstract_list_index_of(p_self: *AbstractList, p_item: ?*anyopaque) c_int;
    pub const indexOf = gee_abstract_list_index_of;

    extern fn gee_abstract_list_insert(p_self: *AbstractList, p_index: c_int, p_item: ?*anyopaque) void;
    pub const insert = gee_abstract_list_insert;

    extern fn gee_abstract_list_remove_at(p_self: *AbstractList, p_index: c_int) ?*anyopaque;
    pub const removeAt = gee_abstract_list_remove_at;

    extern fn gee_abstract_list_slice(p_self: *AbstractList, p_start: c_int, p_stop: c_int) ?*gee.List;
    pub const slice = gee_abstract_list_slice;

    extern fn gee_abstract_list_get_read_only_view(p_self: *AbstractList) *gee.List;
    pub const getReadOnlyView = gee_abstract_list_get_read_only_view;

    extern fn gee_abstract_list_get_type() usize;
    pub const getGObjectType = gee_abstract_list_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMap = extern struct {
    pub const Parent = gobject.Object;
    pub const Implements = [_]type{ gee.Traversable, gee.Iterable, gee.Map };
    pub const Class = gee.AbstractMapClass;
    f_parent_instance: gobject.Object,
    f_priv: ?*gee.AbstractMapPrivate,

    pub const virtual_methods = struct {
        pub const has_key = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractMap.Class, p_class).f_has_key.?(gobject.ext.as(AbstractMap, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_has_key = @ptrCast(p_implementation);
            }
        };

        pub const has = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractMap.Class, p_class).f_has.?(gobject.ext.as(AbstractMap, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_has = @ptrCast(p_implementation);
            }
        };

        pub const get = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get.?(gobject.ext.as(AbstractMap, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get = @ptrCast(p_implementation);
            }
        };

        pub const set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_set.?(gobject.ext.as(AbstractMap, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_set = @ptrCast(p_implementation);
            }
        };

        pub const unset = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractMap.Class, p_class).f_unset.?(gobject.ext.as(AbstractMap, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_unset = @ptrCast(p_implementation);
            }
        };

        pub const map_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MapIterator {
                return gobject.ext.as(AbstractMap.Class, p_class).f_map_iterator.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MapIterator) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_map_iterator = @ptrCast(p_implementation);
            }
        };

        pub const clear = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_clear.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_clear = @ptrCast(p_implementation);
            }
        };

        pub const foreach = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) c_int {
                return gobject.ext.as(AbstractMap.Class, p_class).f_foreach.?(gobject.ext.as(AbstractMap, p_self), p_f, p_f_target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_foreach = @ptrCast(p_implementation);
            }
        };

        pub const stream = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator {
                return gobject.ext.as(AbstractMap.Class, p_class).f_stream.?(gobject.ext.as(AbstractMap, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target, p_f_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_stream = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMap.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_size = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get_size.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get_size = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get_read_only.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };

        pub const get_keys = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get_keys.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get_keys = @ptrCast(p_implementation);
            }
        };

        pub const get_values = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Collection {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get_values.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Collection) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get_values = @ptrCast(p_implementation);
            }
        };

        pub const get_entries = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get_entries.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get_entries = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Map {
                return gobject.ext.as(AbstractMap.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Map) void {
                gobject.ext.as(AbstractMap.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const size = struct {
            pub const name = "size";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };

        pub const keys = struct {
            pub const name = "keys";

            pub const Type = ?**gee.Set;
        };

        pub const values = struct {
            pub const name = "values";

            pub const Type = ?**gee.Collection;
        };

        pub const entries = struct {
            pub const name = "entries";

            pub const Type = ?**gee.Set;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.Map;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_map_has_key(p_self: *AbstractMap, p_key: ?*anyopaque) c_int;
    pub const hasKey = gee_abstract_map_has_key;

    extern fn gee_abstract_map_has(p_self: *AbstractMap, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int;
    pub const has = gee_abstract_map_has;

    extern fn gee_abstract_map_get(p_self: *AbstractMap, p_key: ?*anyopaque) ?*anyopaque;
    pub const get = gee_abstract_map_get;

    extern fn gee_abstract_map_set(p_self: *AbstractMap, p_key: ?*anyopaque, p_value: ?*anyopaque) void;
    pub const set = gee_abstract_map_set;

    extern fn gee_abstract_map_unset(p_self: *AbstractMap, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int;
    pub const unset = gee_abstract_map_unset;

    extern fn gee_abstract_map_map_iterator(p_self: *AbstractMap) *gee.MapIterator;
    pub const mapIterator = gee_abstract_map_map_iterator;

    extern fn gee_abstract_map_clear(p_self: *AbstractMap) void;
    pub const clear = gee_abstract_map_clear;

    extern fn gee_abstract_map_foreach(p_self: *AbstractMap, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) c_int;
    pub const foreach = gee_abstract_map_foreach;

    extern fn gee_abstract_map_stream(p_self: *AbstractMap, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator;
    pub const stream = gee_abstract_map_stream;

    extern fn gee_abstract_map_get_size(p_self: *AbstractMap) c_int;
    pub const getSize = gee_abstract_map_get_size;

    extern fn gee_abstract_map_get_read_only(p_self: *AbstractMap) c_int;
    pub const getReadOnly = gee_abstract_map_get_read_only;

    extern fn gee_abstract_map_get_keys(p_self: *AbstractMap) *gee.Set;
    pub const getKeys = gee_abstract_map_get_keys;

    extern fn gee_abstract_map_get_values(p_self: *AbstractMap) *gee.Collection;
    pub const getValues = gee_abstract_map_get_values;

    extern fn gee_abstract_map_get_entries(p_self: *AbstractMap) *gee.Set;
    pub const getEntries = gee_abstract_map_get_entries;

    extern fn gee_abstract_map_get_read_only_view(p_self: *AbstractMap) *gee.Map;
    pub const getReadOnlyView = gee_abstract_map_get_read_only_view;

    extern fn gee_abstract_map_get_type() usize;
    pub const getGObjectType = gee_abstract_map_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMultiMap = extern struct {
    pub const Parent = gobject.Object;
    pub const Implements = [_]type{gee.MultiMap};
    pub const Class = gee.AbstractMultiMapClass;
    f_parent_instance: gobject.Object,
    f_priv: ?*gee.AbstractMultiMapPrivate,
    f__storage_map: ?*gee.Map,

    pub const virtual_methods = struct {
        pub const create_value_storage = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Collection {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_create_value_storage.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Collection) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_create_value_storage = @ptrCast(p_implementation);
            }
        };

        pub const create_multi_key_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MultiSet {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_create_multi_key_set.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MultiSet) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_create_multi_key_set = @ptrCast(p_implementation);
            }
        };

        pub const get_value_equal_func = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) gee.EqualDataFunc {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_get_value_equal_func.?(gobject.ext.as(AbstractMultiMap, p_self), p_result_target, p_result_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) callconv(.c) gee.EqualDataFunc) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_get_value_equal_func = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MultiMap {
                return gobject.ext.as(AbstractMultiMap.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractMultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MultiMap) void {
                gobject.ext.as(AbstractMultiMap.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_multi_map_create_value_storage(p_self: *AbstractMultiMap) *gee.Collection;
    pub const createValueStorage = gee_abstract_multi_map_create_value_storage;

    extern fn gee_abstract_multi_map_create_multi_key_set(p_self: *AbstractMultiMap) *gee.MultiSet;
    pub const createMultiKeySet = gee_abstract_multi_map_create_multi_key_set;

    extern fn gee_abstract_multi_map_get_value_equal_func(p_self: *AbstractMultiMap, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) gee.EqualDataFunc;
    pub const getValueEqualFunc = gee_abstract_multi_map_get_value_equal_func;

    extern fn gee_abstract_multi_map_get_read_only_view(p_self: *AbstractMultiMap) *gee.MultiMap;
    pub const getReadOnlyView = gee_abstract_multi_map_get_read_only_view;

    extern fn gee_abstract_multi_map_get_type() usize;
    pub const getGObjectType = gee_abstract_multi_map_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractMultiMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractMultiMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractMultiMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMultiSet = extern struct {
    pub const Parent = gee.AbstractCollection;
    pub const Implements = [_]type{gee.MultiSet};
    pub const Class = gee.AbstractMultiSetClass;
    f_parent_instance: gee.AbstractCollection,
    f_priv: ?*gee.AbstractMultiSetPrivate,
    f__storage_map: ?*gee.Map,

    pub const virtual_methods = struct {
        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MultiSet {
                return gobject.ext.as(AbstractMultiSet.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractMultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MultiSet) void {
                gobject.ext.as(AbstractMultiSet.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_multi_set_get_read_only_view(p_self: *AbstractMultiSet) *gee.MultiSet;
    pub const getReadOnlyView = gee_abstract_multi_set_get_read_only_view;

    extern fn gee_abstract_multi_set_get_type() usize;
    pub const getGObjectType = gee_abstract_multi_set_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractMultiSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractMultiSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractMultiSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractQueue = extern struct {
    pub const Parent = gee.AbstractCollection;
    pub const Implements = [_]type{gee.Queue};
    pub const Class = gee.AbstractQueueClass;
    f_parent_instance: gee.AbstractCollection,
    f_priv: ?*gee.AbstractQueuePrivate,

    pub const virtual_methods = struct {
        pub const peek = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_peek.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_peek = @ptrCast(p_implementation);
            }
        };

        pub const poll = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_poll.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_poll = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_capacity = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_get_capacity.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_get_capacity = @ptrCast(p_implementation);
            }
        };

        pub const get_remaining_capacity = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_get_remaining_capacity.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_get_remaining_capacity = @ptrCast(p_implementation);
            }
        };

        pub const get_is_full = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(AbstractQueue.Class, p_class).f_get_is_full.?(gobject.ext.as(AbstractQueue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(AbstractQueue.Class, p_class).f_get_is_full = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const capacity = struct {
            pub const name = "capacity";

            pub const Type = c_int;
        };

        pub const remaining_capacity = struct {
            pub const name = "remaining-capacity";

            pub const Type = c_int;
        };

        pub const is_full = struct {
            pub const name = "is-full";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_queue_peek(p_self: *AbstractQueue) ?*anyopaque;
    pub const peek = gee_abstract_queue_peek;

    extern fn gee_abstract_queue_poll(p_self: *AbstractQueue) ?*anyopaque;
    pub const poll = gee_abstract_queue_poll;

    extern fn gee_abstract_queue_get_capacity(p_self: *AbstractQueue) c_int;
    pub const getCapacity = gee_abstract_queue_get_capacity;

    extern fn gee_abstract_queue_get_remaining_capacity(p_self: *AbstractQueue) c_int;
    pub const getRemainingCapacity = gee_abstract_queue_get_remaining_capacity;

    extern fn gee_abstract_queue_get_is_full(p_self: *AbstractQueue) c_int;
    pub const getIsFull = gee_abstract_queue_get_is_full;

    extern fn gee_abstract_queue_get_type() usize;
    pub const getGObjectType = gee_abstract_queue_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractQueue) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractQueue) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractQueue, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSet = extern struct {
    pub const Parent = gee.AbstractCollection;
    pub const Implements = [_]type{gee.Set};
    pub const Class = gee.AbstractSetClass;
    f_parent_instance: gee.AbstractCollection,
    f_priv: ?*gee.AbstractSetPrivate,

    pub const virtual_methods = struct {
        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSet.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(AbstractSet.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(AbstractSet.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.Set;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_set_get_read_only_view(p_self: *AbstractSet) *gee.Set;
    pub const getReadOnlyView = gee_abstract_set_get_read_only_view;

    extern fn gee_abstract_set_get_type() usize;
    pub const getGObjectType = gee_abstract_set_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSortedMap = extern struct {
    pub const Parent = gee.AbstractMap;
    pub const Implements = [_]type{gee.SortedMap};
    pub const Class = gee.AbstractSortedMapClass;
    f_parent_instance: gee.AbstractMap,
    f_priv: ?*gee.AbstractSortedMapPrivate,

    pub const virtual_methods = struct {
        pub const head_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) *gee.SortedMap {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_head_map.?(gobject.ext.as(AbstractSortedMap, p_self), p_before);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_head_map = @ptrCast(p_implementation);
            }
        };

        pub const tail_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) *gee.SortedMap {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_tail_map.?(gobject.ext.as(AbstractSortedMap, p_self), p_after);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_tail_map = @ptrCast(p_implementation);
            }
        };

        pub const sub_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque, p_after: ?*anyopaque) *gee.SortedMap {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_sub_map.?(gobject.ext.as(AbstractSortedMap, p_self), p_before, p_after);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_sub_map = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_ascending_keys = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedSet {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_get_ascending_keys.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_get_ascending_keys = @ptrCast(p_implementation);
            }
        };

        pub const get_ascending_entries = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedSet {
                return gobject.ext.as(AbstractSortedMap.Class, p_class).f_get_ascending_entries.?(gobject.ext.as(AbstractSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(AbstractSortedMap.Class, p_class).f_get_ascending_entries = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const ascending_keys = struct {
            pub const name = "ascending-keys";

            pub const Type = ?**gee.SortedSet;
        };

        pub const ascending_entries = struct {
            pub const name = "ascending-entries";

            pub const Type = ?**gee.SortedSet;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_sorted_map_head_map(p_self: *AbstractSortedMap, p_before: ?*anyopaque) *gee.SortedMap;
    pub const headMap = gee_abstract_sorted_map_head_map;

    extern fn gee_abstract_sorted_map_tail_map(p_self: *AbstractSortedMap, p_after: ?*anyopaque) *gee.SortedMap;
    pub const tailMap = gee_abstract_sorted_map_tail_map;

    extern fn gee_abstract_sorted_map_sub_map(p_self: *AbstractSortedMap, p_before: ?*anyopaque, p_after: ?*anyopaque) *gee.SortedMap;
    pub const subMap = gee_abstract_sorted_map_sub_map;

    extern fn gee_abstract_sorted_map_get_ascending_keys(p_self: *AbstractSortedMap) *gee.SortedSet;
    pub const getAscendingKeys = gee_abstract_sorted_map_get_ascending_keys;

    extern fn gee_abstract_sorted_map_get_ascending_entries(p_self: *AbstractSortedMap) *gee.SortedSet;
    pub const getAscendingEntries = gee_abstract_sorted_map_get_ascending_entries;

    extern fn gee_abstract_sorted_map_get_type() usize;
    pub const getGObjectType = gee_abstract_sorted_map_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractSortedMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractSortedMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractSortedMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSortedSet = extern struct {
    pub const Parent = gee.AbstractSet;
    pub const Implements = [_]type{gee.SortedSet};
    pub const Class = gee.AbstractSortedSetClass;
    f_parent_instance: gee.AbstractSet,
    f_priv: ?*gee.AbstractSortedSetPrivate,

    pub const virtual_methods = struct {
        pub const first = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_first.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_first = @ptrCast(p_implementation);
            }
        };

        pub const last = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_last.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_last = @ptrCast(p_implementation);
            }
        };

        pub const iterator_at = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*gee.Iterator {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_iterator_at.?(gobject.ext.as(AbstractSortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*gee.Iterator) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_iterator_at = @ptrCast(p_implementation);
            }
        };

        pub const lower = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_lower.?(gobject.ext.as(AbstractSortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_lower = @ptrCast(p_implementation);
            }
        };

        pub const higher = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_higher.?(gobject.ext.as(AbstractSortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_higher = @ptrCast(p_implementation);
            }
        };

        pub const floor = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_floor.?(gobject.ext.as(AbstractSortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_floor = @ptrCast(p_implementation);
            }
        };

        pub const ceil = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_ceil.?(gobject.ext.as(AbstractSortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_ceil = @ptrCast(p_implementation);
            }
        };

        pub const head_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) *gee.SortedSet {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_head_set.?(gobject.ext.as(AbstractSortedSet, p_self), p_before);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_head_set = @ptrCast(p_implementation);
            }
        };

        pub const tail_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) *gee.SortedSet {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_tail_set.?(gobject.ext.as(AbstractSortedSet, p_self), p_after);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_tail_set = @ptrCast(p_implementation);
            }
        };

        pub const sub_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_from: ?*anyopaque, p_to: ?*anyopaque) *gee.SortedSet {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_sub_set.?(gobject.ext.as(AbstractSortedSet, p_self), p_from, p_to);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_from: ?*anyopaque, p_to: ?*anyopaque) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_sub_set = @ptrCast(p_implementation);
            }
        };

        pub const reserved0 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved0.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved0 = @ptrCast(p_implementation);
            }
        };

        pub const reserved1 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved1.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved1 = @ptrCast(p_implementation);
            }
        };

        pub const reserved2 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved2.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved2 = @ptrCast(p_implementation);
            }
        };

        pub const reserved3 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved3.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved3 = @ptrCast(p_implementation);
            }
        };

        pub const reserved4 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved4.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved4 = @ptrCast(p_implementation);
            }
        };

        pub const reserved5 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved5.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved5 = @ptrCast(p_implementation);
            }
        };

        pub const reserved6 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved6.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved6 = @ptrCast(p_implementation);
            }
        };

        pub const reserved7 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved7.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved7 = @ptrCast(p_implementation);
            }
        };

        pub const reserved8 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved8.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved8 = @ptrCast(p_implementation);
            }
        };

        pub const reserved9 = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved9.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_reserved9 = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedSet {
                return gobject.ext.as(AbstractSortedSet.Class, p_class).f_get_read_only_view.?(gobject.ext.as(AbstractSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(AbstractSortedSet.Class, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.SortedSet;
        };
    };

    pub const signals = struct {};

    extern fn gee_abstract_sorted_set_first(p_self: *AbstractSortedSet) ?*anyopaque;
    pub const first = gee_abstract_sorted_set_first;

    extern fn gee_abstract_sorted_set_last(p_self: *AbstractSortedSet) ?*anyopaque;
    pub const last = gee_abstract_sorted_set_last;

    extern fn gee_abstract_sorted_set_iterator_at(p_self: *AbstractSortedSet, p_element: ?*anyopaque) ?*gee.Iterator;
    pub const iteratorAt = gee_abstract_sorted_set_iterator_at;

    extern fn gee_abstract_sorted_set_lower(p_self: *AbstractSortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const lower = gee_abstract_sorted_set_lower;

    extern fn gee_abstract_sorted_set_higher(p_self: *AbstractSortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const higher = gee_abstract_sorted_set_higher;

    extern fn gee_abstract_sorted_set_floor(p_self: *AbstractSortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const floor = gee_abstract_sorted_set_floor;

    extern fn gee_abstract_sorted_set_ceil(p_self: *AbstractSortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const ceil = gee_abstract_sorted_set_ceil;

    extern fn gee_abstract_sorted_set_head_set(p_self: *AbstractSortedSet, p_before: ?*anyopaque) *gee.SortedSet;
    pub const headSet = gee_abstract_sorted_set_head_set;

    extern fn gee_abstract_sorted_set_tail_set(p_self: *AbstractSortedSet, p_after: ?*anyopaque) *gee.SortedSet;
    pub const tailSet = gee_abstract_sorted_set_tail_set;

    extern fn gee_abstract_sorted_set_sub_set(p_self: *AbstractSortedSet, p_from: ?*anyopaque, p_to: ?*anyopaque) *gee.SortedSet;
    pub const subSet = gee_abstract_sorted_set_sub_set;

    extern fn gee_abstract_sorted_set_get_read_only_view(p_self: *AbstractSortedSet) *gee.SortedSet;
    pub const getReadOnlyView = gee_abstract_sorted_set_get_read_only_view;

    extern fn gee_abstract_sorted_set_get_type() usize;
    pub const getGObjectType = gee_abstract_sorted_set_get_type;

    extern fn g_object_ref(p_self: *gee.AbstractSortedSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.AbstractSortedSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *AbstractSortedSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ArrayList = extern struct {
    pub const Parent = gee.AbstractBidirList;
    pub const Implements = [_]type{};
    pub const Class = gee.ArrayListClass;
    f_parent_instance: gee.AbstractBidirList,
    f_priv: ?*gee.ArrayListPrivate,
    f__items: ?[*]*anyopaque,
    f__items_length1: c_int,
    f__size: c_int,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_array_list_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.ArrayList;
    pub const new = gee_array_list_new;

    extern fn gee_array_list_new_wrap(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_items: [*]*anyopaque, p_items_length1: c_int, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.ArrayList;
    pub const wrap = gee_array_list_new_wrap;

    extern fn gee_array_list_add_all(p_self: *ArrayList, p_collection: *gee.Collection) c_int;
    pub const addAll = gee_array_list_add_all;

    extern fn gee_array_list_get_equal_func(p_self: *ArrayList, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_array_list_get_equal_func;

    extern fn gee_array_list_get_type() usize;
    pub const getGObjectType = gee_array_list_get_type;

    extern fn g_object_ref(p_self: *gee.ArrayList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.ArrayList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *ArrayList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ArrayQueue = extern struct {
    pub const Parent = gee.AbstractQueue;
    pub const Implements = [_]type{gee.Deque};
    pub const Class = gee.ArrayQueueClass;
    f_parent_instance: gee.AbstractQueue,
    f_priv: ?*gee.ArrayQueuePrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const is_empty = struct {
            pub const name = "is-empty";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_array_queue_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.ArrayQueue;
    pub const new = gee_array_queue_new;

    extern fn gee_array_queue_get_equal_func(p_self: *ArrayQueue, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_array_queue_get_equal_func;

    extern fn gee_array_queue_get_is_empty(p_self: *ArrayQueue) c_int;
    pub const getIsEmpty = gee_array_queue_get_is_empty;

    extern fn gee_array_queue_get_type() usize;
    pub const getGObjectType = gee_array_queue_get_type;

    extern fn g_object_ref(p_self: *gee.ArrayQueue) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.ArrayQueue) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *ArrayQueue, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentList = extern struct {
    pub const Parent = gee.AbstractList;
    pub const Implements = [_]type{};
    pub const Class = gee.ConcurrentListClass;
    f_parent_instance: gee.AbstractList,
    f_priv: ?*gee.ConcurrentListPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const is_empty = struct {
            pub const name = "is-empty";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_concurrent_list_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.ConcurrentList;
    pub const new = gee_concurrent_list_new;

    extern fn gee_concurrent_list_get_equal_func(p_self: *ConcurrentList, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_concurrent_list_get_equal_func;

    extern fn gee_concurrent_list_get_is_empty(p_self: *ConcurrentList) c_int;
    pub const getIsEmpty = gee_concurrent_list_get_is_empty;

    extern fn gee_concurrent_list_get_type() usize;
    pub const getGObjectType = gee_concurrent_list_get_type;

    extern fn g_object_ref(p_self: *gee.ConcurrentList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.ConcurrentList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *ConcurrentList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentSet = extern struct {
    pub const Parent = gee.AbstractSortedSet;
    pub const Implements = [_]type{};
    pub const Class = gee.ConcurrentSetClass;
    f_parent_instance: gee.AbstractSortedSet,
    f_priv: ?*gee.ConcurrentSetPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_concurrent_set_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) *gee.ConcurrentSet;
    pub const new = gee_concurrent_set_new;

    extern fn gee_concurrent_set_get_type() usize;
    pub const getGObjectType = gee_concurrent_set_get_type;

    extern fn g_object_ref(p_self: *gee.ConcurrentSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.ConcurrentSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *ConcurrentSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMap = extern struct {
    pub const Parent = gee.AbstractMap;
    pub const Implements = [_]type{};
    pub const Class = gee.HashMapClass;
    f_parent_instance: gee.AbstractMap,
    f_priv: ?*gee.HashMapPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_hash_map_new(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify, p_key_hash_func: ?gee.HashDataFunc, p_key_hash_func_target: ?*anyopaque, p_key_hash_func_target_destroy_notify: ?glib.DestroyNotify, p_key_equal_func: ?gee.EqualDataFunc, p_key_equal_func_target: ?*anyopaque, p_key_equal_func_target_destroy_notify: ?glib.DestroyNotify, p_value_equal_func: ?gee.EqualDataFunc, p_value_equal_func_target: ?*anyopaque, p_value_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.HashMap;
    pub const new = gee_hash_map_new;

    extern fn gee_hash_map_get_key_hash_func(p_self: *HashMap, p_result_target: ?*anyopaque) gee.HashDataFunc;
    pub const getKeyHashFunc = gee_hash_map_get_key_hash_func;

    extern fn gee_hash_map_get_key_equal_func(p_self: *HashMap, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getKeyEqualFunc = gee_hash_map_get_key_equal_func;

    extern fn gee_hash_map_get_value_equal_func(p_self: *HashMap, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getValueEqualFunc = gee_hash_map_get_value_equal_func;

    extern fn gee_hash_map_get_type() usize;
    pub const getGObjectType = gee_hash_map_get_type;

    extern fn g_object_ref(p_self: *gee.HashMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.HashMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *HashMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMultiMap = extern struct {
    pub const Parent = gee.AbstractMultiMap;
    pub const Implements = [_]type{};
    pub const Class = gee.HashMultiMapClass;
    f_parent_instance: gee.AbstractMultiMap,
    f_priv: ?*gee.HashMultiMapPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_hash_multi_map_new(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify, p_key_hash_func: ?gee.HashDataFunc, p_key_hash_func_target: ?*anyopaque, p_key_hash_func_target_destroy_notify: ?glib.DestroyNotify, p_key_equal_func: ?gee.EqualDataFunc, p_key_equal_func_target: ?*anyopaque, p_key_equal_func_target_destroy_notify: ?glib.DestroyNotify, p_value_hash_func: ?gee.HashDataFunc, p_value_hash_func_target: ?*anyopaque, p_value_hash_func_target_destroy_notify: ?glib.DestroyNotify, p_value_equal_func: ?gee.EqualDataFunc, p_value_equal_func_target: ?*anyopaque, p_value_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.HashMultiMap;
    pub const new = gee_hash_multi_map_new;

    extern fn gee_hash_multi_map_get_key_hash_func(p_self: *HashMultiMap, p_result_target: ?*anyopaque) gee.HashDataFunc;
    pub const getKeyHashFunc = gee_hash_multi_map_get_key_hash_func;

    extern fn gee_hash_multi_map_get_key_equal_func(p_self: *HashMultiMap, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getKeyEqualFunc = gee_hash_multi_map_get_key_equal_func;

    extern fn gee_hash_multi_map_get_value_hash_func(p_self: *HashMultiMap, p_result_target: ?*anyopaque) gee.HashDataFunc;
    pub const getValueHashFunc = gee_hash_multi_map_get_value_hash_func;

    extern fn gee_hash_multi_map_get_value_equal_func(p_self: *HashMultiMap, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getValueEqualFunc = gee_hash_multi_map_get_value_equal_func;

    extern fn gee_hash_multi_map_get_type() usize;
    pub const getGObjectType = gee_hash_multi_map_get_type;

    extern fn g_object_ref(p_self: *gee.HashMultiMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.HashMultiMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *HashMultiMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMultiSet = extern struct {
    pub const Parent = gee.AbstractMultiSet;
    pub const Implements = [_]type{};
    pub const Class = gee.HashMultiSetClass;
    f_parent_instance: gee.AbstractMultiSet,
    f_priv: ?*gee.HashMultiSetPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_hash_multi_set_new_fixed(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_hash_func: ?gee.HashDataFunc, p_hash_func_target: ?*anyopaque, p_hash_func_target_destroy_notify: ?glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.HashMultiSet;
    pub const new = gee_hash_multi_set_new_fixed;

    extern fn gee_hash_multi_set_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_hash_func: ?gee.HashDataFunc, p_hash_func_target: ?*anyopaque, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque) *gee.HashMultiSet;
    pub const broken = gee_hash_multi_set_new;

    extern fn gee_hash_multi_set_get_hash_func(p_self: *HashMultiSet, p_result_target: ?*anyopaque) gee.HashDataFunc;
    pub const getHashFunc = gee_hash_multi_set_get_hash_func;

    extern fn gee_hash_multi_set_get_equal_func(p_self: *HashMultiSet, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_hash_multi_set_get_equal_func;

    extern fn gee_hash_multi_set_get_type() usize;
    pub const getGObjectType = gee_hash_multi_set_get_type;

    extern fn g_object_ref(p_self: *gee.HashMultiSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.HashMultiSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *HashMultiSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashSet = extern struct {
    pub const Parent = gee.AbstractSet;
    pub const Implements = [_]type{};
    pub const Class = gee.HashSetClass;
    f_parent_instance: gee.AbstractSet,
    f_priv: ?*gee.HashSetPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_hash_set_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_hash_func: ?gee.HashDataFunc, p_hash_func_target: ?*anyopaque, p_hash_func_target_destroy_notify: ?glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.HashSet;
    pub const new = gee_hash_set_new;

    extern fn gee_hash_set_get_hash_func(p_self: *HashSet, p_result_target: ?*anyopaque) gee.HashDataFunc;
    pub const getHashFunc = gee_hash_set_get_hash_func;

    extern fn gee_hash_set_get_equal_func(p_self: *HashSet, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_hash_set_get_equal_func;

    extern fn gee_hash_set_get_type() usize;
    pub const getGObjectType = gee_hash_set_get_type;

    extern fn g_object_ref(p_self: *gee.HashSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.HashSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *HashSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Lazy = extern struct {
    pub const Parent = gobject.TypeInstance;
    pub const Implements = [_]type{};
    pub const Class = gee.LazyClass;
    f_parent_instance: gobject.TypeInstance,
    f_ref_count: c_int,
    f_priv: ?*gee.LazyPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_lazy_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_func: gee.LazyFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Lazy;
    pub const new = gee_lazy_new;

    extern fn gee_lazy_new_from_value(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_item: ?*anyopaque) *gee.Lazy;
    pub const fromValue = gee_lazy_new_from_value;

    extern fn gee_lazy_eval(p_self: *Lazy) void;
    pub const eval = gee_lazy_eval;

    extern fn gee_lazy_get(p_self: *Lazy) ?*anyopaque;
    pub const get = gee_lazy_get;

    extern fn gee_lazy_get_value(p_self: *Lazy) ?*anyopaque;
    pub const getValue = gee_lazy_get_value;

    extern fn gee_lazy_get_future(p_self: *Lazy) ?*gee.Future;
    pub const getFuture = gee_lazy_get_future;

    extern fn gee_lazy_get_type() usize;
    pub const getGObjectType = gee_lazy_get_type;

    extern fn gee_lazy_ref(p_self: *gee.Lazy) void;
    pub const ref = gee_lazy_ref;

    extern fn gee_lazy_unref(p_self: *gee.Lazy) void;
    pub const unref = gee_lazy_unref;

    pub fn as(p_instance: *Lazy, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const LinkedList = extern struct {
    pub const Parent = gee.AbstractBidirList;
    pub const Implements = [_]type{ gee.Queue, gee.Deque };
    pub const Class = gee.LinkedListClass;
    f_parent_instance: gee.AbstractBidirList,
    f_priv: ?*gee.LinkedListPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_linked_list_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.LinkedList;
    pub const new = gee_linked_list_new;

    extern fn gee_linked_list_first(p_self: *LinkedList) ?*anyopaque;
    pub const first = gee_linked_list_first;

    extern fn gee_linked_list_last(p_self: *LinkedList) ?*anyopaque;
    pub const last = gee_linked_list_last;

    extern fn gee_linked_list_get_equal_func(p_self: *LinkedList, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_linked_list_get_equal_func;

    extern fn gee_linked_list_get_type() usize;
    pub const getGObjectType = gee_linked_list_get_type;

    extern fn g_object_ref(p_self: *gee.LinkedList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.LinkedList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *LinkedList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const PriorityQueue = extern struct {
    pub const Parent = gee.AbstractQueue;
    pub const Implements = [_]type{};
    pub const Class = gee.PriorityQueueClass;
    f_parent_instance: gee.AbstractQueue,
    f_priv: ?*gee.PriorityQueuePrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_priority_queue_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) *gee.PriorityQueue;
    pub const new = gee_priority_queue_new;

    extern fn gee_priority_queue_offer(p_self: *PriorityQueue, p_element: ?*anyopaque) c_int;
    pub const offer = gee_priority_queue_offer;

    extern fn gee_priority_queue_drain(p_self: *PriorityQueue, p_recipient: *gee.Collection, p_amount: c_int) c_int;
    pub const drain = gee_priority_queue_drain;

    extern fn gee_priority_queue_get_compare_func(p_self: *PriorityQueue, p_result_target: ?*anyopaque) glib.CompareDataFunc;
    pub const getCompareFunc = gee_priority_queue_get_compare_func;

    extern fn gee_priority_queue_get_type() usize;
    pub const getGObjectType = gee_priority_queue_get_type;

    extern fn g_object_ref(p_self: *gee.PriorityQueue) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.PriorityQueue) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *PriorityQueue, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Promise = extern struct {
    pub const Parent = gobject.TypeInstance;
    pub const Implements = [_]type{};
    pub const Class = gee.PromiseClass;
    f_parent_instance: gobject.TypeInstance,
    f_ref_count: c_int,
    f_priv: ?*gee.PromisePrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_promise_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.Promise;
    pub const new = gee_promise_new;

    extern fn gee_promise_set_value(p_self: *Promise, p_value: ?*anyopaque) void;
    pub const setValue = gee_promise_set_value;

    extern fn gee_promise_set_exception(p_self: *Promise, p_exception: *glib.Error) void;
    pub const setException = gee_promise_set_exception;

    extern fn gee_promise_get_future(p_self: *Promise) *gee.Future;
    pub const getFuture = gee_promise_get_future;

    extern fn gee_promise_get_type() usize;
    pub const getGObjectType = gee_promise_get_type;

    extern fn gee_promise_ref(p_self: *gee.Promise) void;
    pub const ref = gee_promise_ref;

    extern fn gee_promise_unref(p_self: *gee.Promise) void;
    pub const unref = gee_promise_unref;

    pub fn as(p_instance: *Promise, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMap = extern struct {
    pub const Parent = gee.AbstractBidirSortedMap;
    pub const Implements = [_]type{};
    pub const Class = gee.TreeMapClass;
    f_parent_instance: gee.AbstractBidirSortedMap,
    f_priv: ?*gee.TreeMapPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_tree_map_new(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify, p_key_compare_func: ?glib.CompareDataFunc, p_key_compare_func_target: ?*anyopaque, p_key_compare_func_target_destroy_notify: ?glib.DestroyNotify, p_value_equal_func: ?gee.EqualDataFunc, p_value_equal_func_target: ?*anyopaque, p_value_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.TreeMap;
    pub const new = gee_tree_map_new;

    extern fn gee_tree_map_get_key_compare_func(p_self: *TreeMap, p_result_target: ?*anyopaque) glib.CompareDataFunc;
    pub const getKeyCompareFunc = gee_tree_map_get_key_compare_func;

    extern fn gee_tree_map_get_value_equal_func(p_self: *TreeMap, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getValueEqualFunc = gee_tree_map_get_value_equal_func;

    extern fn gee_tree_map_get_type() usize;
    pub const getGObjectType = gee_tree_map_get_type;

    extern fn g_object_ref(p_self: *gee.TreeMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.TreeMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *TreeMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMultiMap = extern struct {
    pub const Parent = gee.AbstractMultiMap;
    pub const Implements = [_]type{};
    pub const Class = gee.TreeMultiMapClass;
    f_parent_instance: gee.AbstractMultiMap,
    f_priv: ?*gee.TreeMultiMapPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_tree_multi_map_new(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify, p_key_compare_func: ?glib.CompareDataFunc, p_key_compare_func_target: ?*anyopaque, p_key_compare_func_target_destroy_notify: ?glib.DestroyNotify, p_value_compare_func: ?glib.CompareDataFunc, p_value_compare_func_target: ?*anyopaque, p_value_compare_func_target_destroy_notify: ?glib.DestroyNotify) *gee.TreeMultiMap;
    pub const new = gee_tree_multi_map_new;

    extern fn gee_tree_multi_map_get_key_compare_func(p_self: *TreeMultiMap, p_result_target: ?*anyopaque) glib.CompareDataFunc;
    pub const getKeyCompareFunc = gee_tree_multi_map_get_key_compare_func;

    extern fn gee_tree_multi_map_get_value_compare_func(p_self: *TreeMultiMap, p_result_target: ?*anyopaque) glib.CompareDataFunc;
    pub const getValueCompareFunc = gee_tree_multi_map_get_value_compare_func;

    extern fn gee_tree_multi_map_get_type() usize;
    pub const getGObjectType = gee_tree_multi_map_get_type;

    extern fn g_object_ref(p_self: *gee.TreeMultiMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.TreeMultiMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *TreeMultiMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMultiSet = extern struct {
    pub const Parent = gee.AbstractMultiSet;
    pub const Implements = [_]type{};
    pub const Class = gee.TreeMultiSetClass;
    f_parent_instance: gee.AbstractMultiSet,
    f_priv: ?*gee.TreeMultiSetPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_tree_multi_set_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) *gee.TreeMultiSet;
    pub const new = gee_tree_multi_set_new;

    extern fn gee_tree_multi_set_get_compare_func(p_self: *TreeMultiSet, p_result_target: ?*anyopaque) glib.CompareDataFunc;
    pub const getCompareFunc = gee_tree_multi_set_get_compare_func;

    extern fn gee_tree_multi_set_get_type() usize;
    pub const getGObjectType = gee_tree_multi_set_get_type;

    extern fn g_object_ref(p_self: *gee.TreeMultiSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.TreeMultiSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *TreeMultiSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeSet = extern struct {
    pub const Parent = gee.AbstractBidirSortedSet;
    pub const Implements = [_]type{};
    pub const Class = gee.TreeSetClass;
    f_parent_instance: gee.AbstractBidirSortedSet,
    f_priv: ?*gee.TreeSetPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_tree_set_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) *gee.TreeSet;
    pub const new = gee_tree_set_new;

    extern fn gee_tree_set_get_compare_func(p_self: *TreeSet, p_result_target: ?*anyopaque) glib.CompareDataFunc;
    pub const getCompareFunc = gee_tree_set_get_compare_func;

    extern fn gee_tree_set_get_type() usize;
    pub const getGObjectType = gee_tree_set_get_type;

    extern fn g_object_ref(p_self: *gee.TreeSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.TreeSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *TreeSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const UnrolledLinkedList = extern struct {
    pub const Parent = gee.AbstractBidirList;
    pub const Implements = [_]type{ gee.Queue, gee.Deque };
    pub const Class = gee.UnrolledLinkedListClass;
    f_parent_instance: gee.AbstractBidirList,
    f_priv: ?*gee.UnrolledLinkedListPrivate,

    pub const virtual_methods = struct {};

    pub const properties = struct {
        pub const g_type = struct {
            pub const name = "g-type";

            pub const Type = usize;
        };

        pub const g_dup_func = struct {
            pub const name = "g-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const g_destroy_func = struct {
            pub const name = "g-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };
    };

    pub const signals = struct {};

    extern fn gee_unrolled_linked_list_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_equal_func: ?gee.EqualDataFunc, p_equal_func_target: ?*anyopaque, p_equal_func_target_destroy_notify: ?glib.DestroyNotify) *gee.UnrolledLinkedList;
    pub const new = gee_unrolled_linked_list_new;

    extern fn gee_unrolled_linked_list_get_equal_func(p_self: *UnrolledLinkedList, p_result_target: ?*anyopaque) gee.EqualDataFunc;
    pub const getEqualFunc = gee_unrolled_linked_list_get_equal_func;

    extern fn gee_unrolled_linked_list_get_type() usize;
    pub const getGObjectType = gee_unrolled_linked_list_get_type;

    extern fn g_object_ref(p_self: *gee.UnrolledLinkedList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.UnrolledLinkedList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *UnrolledLinkedList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MapEntry = extern struct {
    pub const Parent = gobject.Object;
    pub const Implements = [_]type{};
    pub const Class = gee.MapEntryClass;
    f_parent_instance: gobject.Object,
    f_priv: ?*gee.MapEntryPrivate,

    pub const virtual_methods = struct {
        pub const get_key = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(MapEntry.Class, p_class).f_get_key.?(gobject.ext.as(MapEntry, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(MapEntry.Class, p_class).f_get_key = @ptrCast(p_implementation);
            }
        };

        pub const get_value = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(MapEntry.Class, p_class).f_get_value.?(gobject.ext.as(MapEntry, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(MapEntry.Class, p_class).f_get_value = @ptrCast(p_implementation);
            }
        };

        pub const set_value = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_value: ?*anyopaque) void {
                return gobject.ext.as(MapEntry.Class, p_class).f_set_value.?(gobject.ext.as(MapEntry, p_self), p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_value: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(MapEntry.Class, p_class).f_set_value = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MapEntry.Class, p_class).f_get_read_only.?(gobject.ext.as(MapEntry, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MapEntry.Class, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const k_type = struct {
            pub const name = "k-type";

            pub const Type = usize;
        };

        pub const k_dup_func = struct {
            pub const name = "k-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const k_destroy_func = struct {
            pub const name = "k-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const v_type = struct {
            pub const name = "v-type";

            pub const Type = usize;
        };

        pub const v_dup_func = struct {
            pub const name = "v-dup-func";

            pub const Type = ?gobject.BoxedCopyFunc;
        };

        pub const v_destroy_func = struct {
            pub const name = "v-destroy-func";

            pub const Type = ?glib.DestroyNotify;
        };

        pub const key = struct {
            pub const name = "key";

            pub const Type = ?*anyopaque;
        };

        pub const value = struct {
            pub const name = "value";

            pub const Type = ?*anyopaque;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_map_entry_get_key(p_self: *MapEntry) ?*anyopaque;
    pub const getKey = gee_map_entry_get_key;

    extern fn gee_map_entry_get_value(p_self: *MapEntry) ?*anyopaque;
    pub const getValue = gee_map_entry_get_value;

    extern fn gee_map_entry_set_value(p_self: *MapEntry, p_value: ?*anyopaque) void;
    pub const setValue = gee_map_entry_set_value;

    extern fn gee_map_entry_get_read_only(p_self: *MapEntry) c_int;
    pub const getReadOnly = gee_map_entry_get_read_only;

    extern fn gee_map_entry_get_type() usize;
    pub const getGObjectType = gee_map_entry_get_type;

    extern fn g_object_ref(p_self: *gee.MapEntry) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.MapEntry) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *MapEntry, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirIterator = opaque {
    pub const Prerequisites = [_]type{gee.Iterator};
    pub const Iface = gee.BidirIteratorIface;
    pub const virtual_methods = struct {
        pub const previous = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirIterator.Iface, p_class).f_previous.?(gobject.ext.as(BidirIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirIterator.Iface, p_class).f_previous = @ptrCast(p_implementation);
            }
        };

        pub const has_previous = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirIterator.Iface, p_class).f_has_previous.?(gobject.ext.as(BidirIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirIterator.Iface, p_class).f_has_previous = @ptrCast(p_implementation);
            }
        };

        pub const first = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirIterator.Iface, p_class).f_first.?(gobject.ext.as(BidirIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirIterator.Iface, p_class).f_first = @ptrCast(p_implementation);
            }
        };

        pub const last = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirIterator.Iface, p_class).f_last.?(gobject.ext.as(BidirIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirIterator.Iface, p_class).f_last = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_bidir_iterator_previous(p_self: *BidirIterator) c_int;
    pub const previous = gee_bidir_iterator_previous;

    extern fn gee_bidir_iterator_has_previous(p_self: *BidirIterator) c_int;
    pub const hasPrevious = gee_bidir_iterator_has_previous;

    extern fn gee_bidir_iterator_first(p_self: *BidirIterator) c_int;
    pub const first = gee_bidir_iterator_first;

    extern fn gee_bidir_iterator_last(p_self: *BidirIterator) c_int;
    pub const last = gee_bidir_iterator_last;

    extern fn gee_bidir_iterator_get_type() usize;
    pub const getGObjectType = gee_bidir_iterator_get_type;

    extern fn g_object_ref(p_self: *gee.BidirIterator) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.BidirIterator) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *BidirIterator, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirList = opaque {
    pub const Prerequisites = [_]type{gee.List};
    pub const Iface = gee.BidirListIface;
    pub const virtual_methods = struct {
        pub const bidir_list_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirListIterator {
                return gobject.ext.as(BidirList.Iface, p_class).f_bidir_list_iterator.?(gobject.ext.as(BidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirListIterator) void {
                gobject.ext.as(BidirList.Iface, p_class).f_bidir_list_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirList {
                return gobject.ext.as(BidirList.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(BidirList, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirList) void {
                gobject.ext.as(BidirList.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.BidirList;
        };
    };

    pub const signals = struct {};

    extern fn gee_bidir_list_bidir_list_iterator(p_self: *BidirList) *gee.BidirListIterator;
    pub const bidirListIterator = gee_bidir_list_bidir_list_iterator;

    extern fn gee_bidir_list_get_read_only_view(p_self: *BidirList) *gee.BidirList;
    pub const getReadOnlyView = gee_bidir_list_get_read_only_view;

    extern fn gee_bidir_list_get_type() usize;
    pub const getGObjectType = gee_bidir_list_get_type;

    extern fn g_object_ref(p_self: *gee.BidirList) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.BidirList) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *BidirList, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirListIterator = opaque {
    pub const Prerequisites = [_]type{ gee.BidirIterator, gee.ListIterator };
    pub const Iface = gee.BidirListIteratorIface;
    pub const virtual_methods = struct {
        pub const insert = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) void {
                return gobject.ext.as(BidirListIterator.Iface, p_class).f_insert.?(gobject.ext.as(BidirListIterator, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(BidirListIterator.Iface, p_class).f_insert = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_bidir_list_iterator_insert(p_self: *BidirListIterator, p_item: ?*anyopaque) void;
    pub const insert = gee_bidir_list_iterator_insert;

    extern fn gee_bidir_list_iterator_get_type() usize;
    pub const getGObjectType = gee_bidir_list_iterator_get_type;

    extern fn g_object_ref(p_self: *gee.BidirListIterator) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.BidirListIterator) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *BidirListIterator, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirMapIterator = opaque {
    pub const Prerequisites = [_]type{gee.MapIterator};
    pub const Iface = gee.BidirMapIteratorIface;
    pub const virtual_methods = struct {
        pub const previous = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirMapIterator.Iface, p_class).f_previous.?(gobject.ext.as(BidirMapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirMapIterator.Iface, p_class).f_previous = @ptrCast(p_implementation);
            }
        };

        pub const has_previous = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirMapIterator.Iface, p_class).f_has_previous.?(gobject.ext.as(BidirMapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirMapIterator.Iface, p_class).f_has_previous = @ptrCast(p_implementation);
            }
        };

        pub const first = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirMapIterator.Iface, p_class).f_first.?(gobject.ext.as(BidirMapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirMapIterator.Iface, p_class).f_first = @ptrCast(p_implementation);
            }
        };

        pub const last = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(BidirMapIterator.Iface, p_class).f_last.?(gobject.ext.as(BidirMapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(BidirMapIterator.Iface, p_class).f_last = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_bidir_map_iterator_previous(p_self: *BidirMapIterator) c_int;
    pub const previous = gee_bidir_map_iterator_previous;

    extern fn gee_bidir_map_iterator_has_previous(p_self: *BidirMapIterator) c_int;
    pub const hasPrevious = gee_bidir_map_iterator_has_previous;

    extern fn gee_bidir_map_iterator_first(p_self: *BidirMapIterator) c_int;
    pub const first = gee_bidir_map_iterator_first;

    extern fn gee_bidir_map_iterator_last(p_self: *BidirMapIterator) c_int;
    pub const last = gee_bidir_map_iterator_last;

    extern fn gee_bidir_map_iterator_get_type() usize;
    pub const getGObjectType = gee_bidir_map_iterator_get_type;

    extern fn g_object_ref(p_self: *gee.BidirMapIterator) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.BidirMapIterator) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *BidirMapIterator, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirSortedSet = opaque {
    pub const Prerequisites = [_]type{gee.SortedSet};
    pub const Iface = gee.BidirSortedSetIface;
    pub const virtual_methods = struct {
        pub const bidir_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirIterator {
                return gobject.ext.as(BidirSortedSet.Iface, p_class).f_bidir_iterator.?(gobject.ext.as(BidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirIterator) void {
                gobject.ext.as(BidirSortedSet.Iface, p_class).f_bidir_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirSortedSet {
                return gobject.ext.as(BidirSortedSet.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(BidirSortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirSortedSet) void {
                gobject.ext.as(BidirSortedSet.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.BidirSortedSet;
        };
    };

    pub const signals = struct {};

    extern fn gee_bidir_sorted_set_empty(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.BidirSortedSet;
    pub const empty = gee_bidir_sorted_set_empty;

    extern fn gee_bidir_sorted_set_bidir_iterator(p_self: *BidirSortedSet) *gee.BidirIterator;
    pub const bidirIterator = gee_bidir_sorted_set_bidir_iterator;

    extern fn gee_bidir_sorted_set_get_read_only_view(p_self: *BidirSortedSet) *gee.BidirSortedSet;
    pub const getReadOnlyView = gee_bidir_sorted_set_get_read_only_view;

    extern fn gee_bidir_sorted_set_get_type() usize;
    pub const getGObjectType = gee_bidir_sorted_set_get_type;

    extern fn g_object_ref(p_self: *gee.BidirSortedSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.BidirSortedSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *BidirSortedSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirSortedMap = opaque {
    pub const Prerequisites = [_]type{gee.SortedMap};
    pub const Iface = gee.BidirSortedMapIface;
    pub const virtual_methods = struct {
        pub const bidir_map_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirMapIterator {
                return gobject.ext.as(BidirSortedMap.Iface, p_class).f_bidir_map_iterator.?(gobject.ext.as(BidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirMapIterator) void {
                gobject.ext.as(BidirSortedMap.Iface, p_class).f_bidir_map_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.BidirSortedMap {
                return gobject.ext.as(BidirSortedMap.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(BidirSortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.BidirSortedMap) void {
                gobject.ext.as(BidirSortedMap.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.BidirSortedMap;
        };
    };

    pub const signals = struct {};

    extern fn gee_bidir_sorted_map_empty(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify) *gee.BidirSortedMap;
    pub const empty = gee_bidir_sorted_map_empty;

    extern fn gee_bidir_sorted_map_bidir_map_iterator(p_self: *BidirSortedMap) *gee.BidirMapIterator;
    pub const bidirMapIterator = gee_bidir_sorted_map_bidir_map_iterator;

    extern fn gee_bidir_sorted_map_get_read_only_view(p_self: *BidirSortedMap) *gee.BidirSortedMap;
    pub const getReadOnlyView = gee_bidir_sorted_map_get_read_only_view;

    extern fn gee_bidir_sorted_map_get_type() usize;
    pub const getGObjectType = gee_bidir_sorted_map_get_type;

    extern fn g_object_ref(p_self: *gee.BidirSortedMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.BidirSortedMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *BidirSortedMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Collection = opaque {
    pub const Prerequisites = [_]type{gee.Iterable};
    pub const Iface = gee.CollectionIface;
    pub const virtual_methods = struct {
        pub const contains = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_contains.?(gobject.ext.as(Collection, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_contains = @ptrCast(p_implementation);
            }
        };

        pub const add = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_add.?(gobject.ext.as(Collection, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_add = @ptrCast(p_implementation);
            }
        };

        pub const remove = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_remove.?(gobject.ext.as(Collection, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_remove = @ptrCast(p_implementation);
            }
        };

        pub const clear = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(Collection.Iface, p_class).f_clear.?(gobject.ext.as(Collection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(Collection.Iface, p_class).f_clear = @ptrCast(p_implementation);
            }
        };

        pub const add_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_add_all.?(gobject.ext.as(Collection, p_self), p_collection);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_add_all = @ptrCast(p_implementation);
            }
        };

        pub const contains_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_contains_all.?(gobject.ext.as(Collection, p_self), p_collection);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_contains_all = @ptrCast(p_implementation);
            }
        };

        pub const remove_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_remove_all.?(gobject.ext.as(Collection, p_self), p_collection);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_remove_all = @ptrCast(p_implementation);
            }
        };

        pub const retain_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_retain_all.?(gobject.ext.as(Collection, p_self), p_collection);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_collection: *gee.Collection) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_retain_all = @ptrCast(p_implementation);
            }
        };

        pub const to_array = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_result_length1: *c_int) [*]*anyopaque {
                return gobject.ext.as(Collection.Iface, p_class).f_to_array.?(gobject.ext.as(Collection, p_self), p_result_length1);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_result_length1: *c_int) callconv(.c) [*]*anyopaque) void {
                gobject.ext.as(Collection.Iface, p_class).f_to_array = @ptrCast(p_implementation);
            }
        };

        pub const add_all_array = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_array: [*]*anyopaque, p_array_length1: c_int) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_add_all_array.?(gobject.ext.as(Collection, p_self), p_array, p_array_length1);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_array: [*]*anyopaque, p_array_length1: c_int) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_add_all_array = @ptrCast(p_implementation);
            }
        };

        pub const contains_all_array = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_array: [*]*anyopaque, p_array_length1: c_int) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_contains_all_array.?(gobject.ext.as(Collection, p_self), p_array, p_array_length1);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_array: [*]*anyopaque, p_array_length1: c_int) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_contains_all_array = @ptrCast(p_implementation);
            }
        };

        pub const remove_all_array = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_array: [*]*anyopaque, p_array_length1: c_int) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_remove_all_array.?(gobject.ext.as(Collection, p_self), p_array, p_array_length1);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_array: [*]*anyopaque, p_array_length1: c_int) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_remove_all_array = @ptrCast(p_implementation);
            }
        };

        pub const add_all_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_iter: *gee.Iterator) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_add_all_iterator.?(gobject.ext.as(Collection, p_self), p_iter);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_iter: *gee.Iterator) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_add_all_iterator = @ptrCast(p_implementation);
            }
        };

        pub const contains_all_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_iter: *gee.Iterator) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_contains_all_iterator.?(gobject.ext.as(Collection, p_self), p_iter);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_iter: *gee.Iterator) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_contains_all_iterator = @ptrCast(p_implementation);
            }
        };

        pub const remove_all_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_iter: *gee.Iterator) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_remove_all_iterator.?(gobject.ext.as(Collection, p_self), p_iter);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_iter: *gee.Iterator) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_remove_all_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get_size = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_get_size.?(gobject.ext.as(Collection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_get_size = @ptrCast(p_implementation);
            }
        };

        pub const get_is_empty = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_get_is_empty.?(gobject.ext.as(Collection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_get_is_empty = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Collection.Iface, p_class).f_get_read_only.?(gobject.ext.as(Collection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Collection.Iface, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Collection {
                return gobject.ext.as(Collection.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(Collection, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Collection) void {
                gobject.ext.as(Collection.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const size = struct {
            pub const name = "size";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.Collection;
        };
    };

    pub const signals = struct {};

    extern fn gee_collection_empty(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.Collection;
    pub const empty = gee_collection_empty;

    extern fn gee_collection_contains(p_self: *Collection, p_item: ?*anyopaque) c_int;
    pub const contains = gee_collection_contains;

    extern fn gee_collection_add(p_self: *Collection, p_item: ?*anyopaque) c_int;
    pub const add = gee_collection_add;

    extern fn gee_collection_remove(p_self: *Collection, p_item: ?*anyopaque) c_int;
    pub const remove = gee_collection_remove;

    extern fn gee_collection_clear(p_self: *Collection) void;
    pub const clear = gee_collection_clear;

    extern fn gee_collection_add_all(p_self: *Collection, p_collection: *gee.Collection) c_int;
    pub const addAll = gee_collection_add_all;

    extern fn gee_collection_contains_all(p_self: *Collection, p_collection: *gee.Collection) c_int;
    pub const containsAll = gee_collection_contains_all;

    extern fn gee_collection_remove_all(p_self: *Collection, p_collection: *gee.Collection) c_int;
    pub const removeAll = gee_collection_remove_all;

    extern fn gee_collection_retain_all(p_self: *Collection, p_collection: *gee.Collection) c_int;
    pub const retainAll = gee_collection_retain_all;

    extern fn gee_collection_to_array(p_self: *Collection, p_result_length1: *c_int) [*]*anyopaque;
    pub const toArray = gee_collection_to_array;

    extern fn gee_collection_add_all_array(p_self: *Collection, p_array: [*]*anyopaque, p_array_length1: c_int) c_int;
    pub const addAllArray = gee_collection_add_all_array;

    extern fn gee_collection_contains_all_array(p_self: *Collection, p_array: [*]*anyopaque, p_array_length1: c_int) c_int;
    pub const containsAllArray = gee_collection_contains_all_array;

    extern fn gee_collection_remove_all_array(p_self: *Collection, p_array: [*]*anyopaque, p_array_length1: c_int) c_int;
    pub const removeAllArray = gee_collection_remove_all_array;

    extern fn gee_collection_add_all_iterator(p_self: *Collection, p_iter: *gee.Iterator) c_int;
    pub const addAllIterator = gee_collection_add_all_iterator;

    extern fn gee_collection_contains_all_iterator(p_self: *Collection, p_iter: *gee.Iterator) c_int;
    pub const containsAllIterator = gee_collection_contains_all_iterator;

    extern fn gee_collection_remove_all_iterator(p_self: *Collection, p_iter: *gee.Iterator) c_int;
    pub const removeAllIterator = gee_collection_remove_all_iterator;

    extern fn gee_collection_get_size(p_self: *Collection) c_int;
    pub const getSize = gee_collection_get_size;

    extern fn gee_collection_get_is_empty(p_self: *Collection) c_int;
    pub const getIsEmpty = gee_collection_get_is_empty;

    extern fn gee_collection_get_read_only(p_self: *Collection) c_int;
    pub const getReadOnly = gee_collection_get_read_only;

    extern fn gee_collection_get_read_only_view(p_self: *Collection) *gee.Collection;
    pub const getReadOnlyView = gee_collection_get_read_only_view;

    extern fn gee_collection_get_type() usize;
    pub const getGObjectType = gee_collection_get_type;

    extern fn g_object_ref(p_self: *gee.Collection) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Collection) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Collection, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Comparable = opaque {
    pub const Prerequisites = [_]type{gobject.Object};
    pub const Iface = gee.ComparableIface;
    pub const virtual_methods = struct {
        pub const compare_to = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_object: ?*anyopaque) c_int {
                return gobject.ext.as(Comparable.Iface, p_class).f_compare_to.?(gobject.ext.as(Comparable, p_self), p_object);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_object: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Comparable.Iface, p_class).f_compare_to = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_comparable_compare_to(p_self: *Comparable, p_object: ?*anyopaque) c_int;
    pub const compareTo = gee_comparable_compare_to;

    extern fn gee_comparable_get_type() usize;
    pub const getGObjectType = gee_comparable_get_type;

    extern fn g_object_ref(p_self: *gee.Comparable) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Comparable) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Comparable, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Deque = opaque {
    pub const Prerequisites = [_]type{gee.Queue};
    pub const Iface = gee.DequeIface;
    pub const virtual_methods = struct {
        pub const offer_head = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) c_int {
                return gobject.ext.as(Deque.Iface, p_class).f_offer_head.?(gobject.ext.as(Deque, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Deque.Iface, p_class).f_offer_head = @ptrCast(p_implementation);
            }
        };

        pub const peek_head = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Deque.Iface, p_class).f_peek_head.?(gobject.ext.as(Deque, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Deque.Iface, p_class).f_peek_head = @ptrCast(p_implementation);
            }
        };

        pub const poll_head = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Deque.Iface, p_class).f_poll_head.?(gobject.ext.as(Deque, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Deque.Iface, p_class).f_poll_head = @ptrCast(p_implementation);
            }
        };

        pub const drain_head = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_recipient: *gee.Collection, p_amount: c_int) c_int {
                return gobject.ext.as(Deque.Iface, p_class).f_drain_head.?(gobject.ext.as(Deque, p_self), p_recipient, p_amount);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_recipient: *gee.Collection, p_amount: c_int) callconv(.c) c_int) void {
                gobject.ext.as(Deque.Iface, p_class).f_drain_head = @ptrCast(p_implementation);
            }
        };

        pub const offer_tail = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) c_int {
                return gobject.ext.as(Deque.Iface, p_class).f_offer_tail.?(gobject.ext.as(Deque, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Deque.Iface, p_class).f_offer_tail = @ptrCast(p_implementation);
            }
        };

        pub const peek_tail = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Deque.Iface, p_class).f_peek_tail.?(gobject.ext.as(Deque, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Deque.Iface, p_class).f_peek_tail = @ptrCast(p_implementation);
            }
        };

        pub const poll_tail = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Deque.Iface, p_class).f_poll_tail.?(gobject.ext.as(Deque, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Deque.Iface, p_class).f_poll_tail = @ptrCast(p_implementation);
            }
        };

        pub const drain_tail = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_recipient: *gee.Collection, p_amount: c_int) c_int {
                return gobject.ext.as(Deque.Iface, p_class).f_drain_tail.?(gobject.ext.as(Deque, p_self), p_recipient, p_amount);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_recipient: *gee.Collection, p_amount: c_int) callconv(.c) c_int) void {
                gobject.ext.as(Deque.Iface, p_class).f_drain_tail = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_deque_offer_head(p_self: *Deque, p_element: ?*anyopaque) c_int;
    pub const offerHead = gee_deque_offer_head;

    extern fn gee_deque_peek_head(p_self: *Deque) ?*anyopaque;
    pub const peekHead = gee_deque_peek_head;

    extern fn gee_deque_poll_head(p_self: *Deque) ?*anyopaque;
    pub const pollHead = gee_deque_poll_head;

    extern fn gee_deque_drain_head(p_self: *Deque, p_recipient: *gee.Collection, p_amount: c_int) c_int;
    pub const drainHead = gee_deque_drain_head;

    extern fn gee_deque_offer_tail(p_self: *Deque, p_element: ?*anyopaque) c_int;
    pub const offerTail = gee_deque_offer_tail;

    extern fn gee_deque_peek_tail(p_self: *Deque) ?*anyopaque;
    pub const peekTail = gee_deque_peek_tail;

    extern fn gee_deque_poll_tail(p_self: *Deque) ?*anyopaque;
    pub const pollTail = gee_deque_poll_tail;

    extern fn gee_deque_drain_tail(p_self: *Deque, p_recipient: *gee.Collection, p_amount: c_int) c_int;
    pub const drainTail = gee_deque_drain_tail;

    extern fn gee_deque_get_type() usize;
    pub const getGObjectType = gee_deque_get_type;

    extern fn g_object_ref(p_self: *gee.Deque) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Deque) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Deque, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Future = opaque {
    pub const Prerequisites = [_]type{gobject.Object};
    pub const Iface = gee.FutureIface;
    pub const virtual_methods = struct {
        pub const wait = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_error: ?*?*glib.Error) ?*anyopaque {
                return gobject.ext.as(Future.Iface, p_class).f_wait.?(gobject.ext.as(Future, p_self), p_error);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_error: ?*?*glib.Error) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Future.Iface, p_class).f_wait = @ptrCast(p_implementation);
            }
        };

        pub const wait_until = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_end_time: i64, p_value: ?*anyopaque, p_error: ?*?*glib.Error) c_int {
                return gobject.ext.as(Future.Iface, p_class).f_wait_until.?(gobject.ext.as(Future, p_self), p_end_time, p_value, p_error);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_end_time: i64, p_value: ?*anyopaque, p_error: ?*?*glib.Error) callconv(.c) c_int) void {
                gobject.ext.as(Future.Iface, p_class).f_wait_until = @ptrCast(p_implementation);
            }
        };

        pub const wait_async = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p__callback_: ?gio.AsyncReadyCallback, p__callback__target: ?*anyopaque) void {
                return gobject.ext.as(Future.Iface, p_class).f_wait_async.?(gobject.ext.as(Future, p_self), p__callback_, p__callback__target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p__callback_: ?gio.AsyncReadyCallback, p__callback__target: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(Future.Iface, p_class).f_wait_async = @ptrCast(p_implementation);
            }
        };

        pub const wait_finish = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p__res_: *gio.AsyncResult, p_error: ?*?*glib.Error) ?*anyopaque {
                return gobject.ext.as(Future.Iface, p_class).f_wait_finish.?(gobject.ext.as(Future, p_self), p__res_, p_error);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p__res_: *gio.AsyncResult, p_error: ?*?*glib.Error) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Future.Iface, p_class).f_wait_finish = @ptrCast(p_implementation);
            }
        };

        pub const map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.MapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Future {
                return gobject.ext.as(Future.Iface, p_class).f_map.?(gobject.ext.as(Future, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_func, p_func_target, p_func_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.MapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Future) void {
                gobject.ext.as(Future.Iface, p_class).f_map = @ptrCast(p_implementation);
            }
        };

        pub const light_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Future {
                return gobject.ext.as(Future.Iface, p_class).f_light_map.?(gobject.ext.as(Future, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_func, p_func_target, p_func_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Future) void {
                gobject.ext.as(Future.Iface, p_class).f_light_map = @ptrCast(p_implementation);
            }
        };

        pub const light_map_broken = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque) *gee.Future {
                return gobject.ext.as(Future.Iface, p_class).f_light_map_broken.?(gobject.ext.as(Future, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_func, p_func_target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque) callconv(.c) *gee.Future) void {
                gobject.ext.as(Future.Iface, p_class).f_light_map_broken = @ptrCast(p_implementation);
            }
        };

        pub const zip = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_b_type: usize, p_b_dup_func: gobject.BoxedCopyFunc, p_b_destroy_func: glib.DestroyNotify, p_zip_func: gee.Future.ZipFunc, p_zip_func_target: ?*anyopaque, p_second: *gee.Future) *gee.Future {
                return gobject.ext.as(Future.Iface, p_class).f_zip.?(gobject.ext.as(Future, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_b_type, p_b_dup_func, p_b_destroy_func, p_zip_func, p_zip_func_target, p_second);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_b_type: usize, p_b_dup_func: gobject.BoxedCopyFunc, p_b_destroy_func: glib.DestroyNotify, p_zip_func: gee.Future.ZipFunc, p_zip_func_target: ?*anyopaque, p_second: *gee.Future) callconv(.c) *gee.Future) void {
                gobject.ext.as(Future.Iface, p_class).f_zip = @ptrCast(p_implementation);
            }
        };

        pub const flat_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.FlatMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Future {
                return gobject.ext.as(Future.Iface, p_class).f_flat_map.?(gobject.ext.as(Future, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_func, p_func_target, p_func_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.FlatMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Future) void {
                gobject.ext.as(Future.Iface, p_class).f_flat_map = @ptrCast(p_implementation);
            }
        };

        pub const get_value = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Future.Iface, p_class).f_get_value.?(gobject.ext.as(Future, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Future.Iface, p_class).f_get_value = @ptrCast(p_implementation);
            }
        };

        pub const get_ready = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Future.Iface, p_class).f_get_ready.?(gobject.ext.as(Future, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Future.Iface, p_class).f_get_ready = @ptrCast(p_implementation);
            }
        };

        pub const get_exception = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*glib.Error {
                return gobject.ext.as(Future.Iface, p_class).f_get_exception.?(gobject.ext.as(Future, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*glib.Error) void {
                gobject.ext.as(Future.Iface, p_class).f_get_exception = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const ready = struct {
            pub const name = "ready";

            pub const Type = c_int;
        };

        pub const exception = struct {
            pub const name = "exception";

            pub const Type = ?**glib.Error;
        };
    };

    pub const signals = struct {};

    pub const MapFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_value: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

    pub const LightMapFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_value: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

    pub const ZipFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_b_type: usize, p_b_dup_func: gobject.BoxedCopyFunc, p_b_destroy_func: glib.DestroyNotify, p_c_type: usize, p_c_dup_func: gobject.BoxedCopyFunc, p_c_destroy_func: glib.DestroyNotify, p_a: ?*anyopaque, p_b: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

    pub const FlatMapFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_value: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) *gee.Future;

    extern fn gee_future_wait(p_self: *Future, p_error: ?*?*glib.Error) ?*anyopaque;
    pub const wait = gee_future_wait;

    extern fn gee_future_wait_until(p_self: *Future, p_end_time: i64, p_value: ?*anyopaque, p_error: ?*?*glib.Error) c_int;
    pub const waitUntil = gee_future_wait_until;

    extern fn gee_future_wait_async(p_self: *Future, p__callback_: ?gio.AsyncReadyCallback, p__callback__target: ?*anyopaque) void;
    pub const waitAsync = gee_future_wait_async;

    extern fn gee_future_wait_finish(p_self: *Future, p__res_: *gio.AsyncResult, p_error: ?*?*glib.Error) ?*anyopaque;
    pub const waitFinish = gee_future_wait_finish;

    extern fn gee_future_map(p_self: *Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.MapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Future;
    pub const map = gee_future_map;

    extern fn gee_future_light_map_fixed(p_self: *Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Future;
    pub const lightMap = gee_future_light_map_fixed;

    extern fn gee_future_light_map(p_self: *Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque) *gee.Future;
    pub const lightMapBroken = gee_future_light_map;

    extern fn gee_future_zip(p_self: *Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_b_type: usize, p_b_dup_func: gobject.BoxedCopyFunc, p_b_destroy_func: glib.DestroyNotify, p_zip_func: gee.Future.ZipFunc, p_zip_func_target: ?*anyopaque, p_second: *gee.Future) *gee.Future;
    pub const zip = gee_future_zip;

    extern fn gee_future_flat_map(p_self: *Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.FlatMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) *gee.Future;
    pub const flatMap = gee_future_flat_map;

    extern fn gee_future_get_value(p_self: *Future) ?*anyopaque;
    pub const getValue = gee_future_get_value;

    extern fn gee_future_get_ready(p_self: *Future) c_int;
    pub const getReady = gee_future_get_ready;

    extern fn gee_future_get_exception(p_self: *Future) ?*glib.Error;
    pub const getException = gee_future_get_exception;

    extern fn gee_future_get_type() usize;
    pub const getGObjectType = gee_future_get_type;

    extern fn g_object_ref(p_self: *gee.Future) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Future) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Future, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Hashable = opaque {
    pub const Prerequisites = [_]type{gobject.Object};
    pub const Iface = gee.HashableIface;
    pub const virtual_methods = struct {
        pub const hash = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_uint {
                return gobject.ext.as(Hashable.Iface, p_class).f_hash.?(gobject.ext.as(Hashable, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_uint) void {
                gobject.ext.as(Hashable.Iface, p_class).f_hash = @ptrCast(p_implementation);
            }
        };

        pub const equal_to = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_object: ?*anyopaque) c_int {
                return gobject.ext.as(Hashable.Iface, p_class).f_equal_to.?(gobject.ext.as(Hashable, p_self), p_object);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_object: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Hashable.Iface, p_class).f_equal_to = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_hashable_hash(p_self: *Hashable) c_uint;
    pub const hash = gee_hashable_hash;

    extern fn gee_hashable_equal_to(p_self: *Hashable, p_object: ?*anyopaque) c_int;
    pub const equalTo = gee_hashable_equal_to;

    extern fn gee_hashable_get_type() usize;
    pub const getGObjectType = gee_hashable_get_type;

    extern fn g_object_ref(p_self: *gee.Hashable) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Hashable) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Hashable, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Iterable = opaque {
    pub const Prerequisites = [_]type{ gobject.Object, gee.Traversable };
    pub const Iface = gee.IterableIface;
    pub const virtual_methods = struct {
        pub const iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Iterator {
                return gobject.ext.as(Iterable.Iface, p_class).f_iterator.?(gobject.ext.as(Iterable, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Iterable.Iface, p_class).f_iterator = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_iterable_iterator(p_self: *Iterable) *gee.Iterator;
    pub const iterator = gee_iterable_iterator;

    extern fn gee_iterable_get_type() usize;
    pub const getGObjectType = gee_iterable_get_type;

    extern fn g_object_ref(p_self: *gee.Iterable) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Iterable) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Iterable, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Iterator = opaque {
    pub const Prerequisites = [_]type{ gobject.Object, gee.Traversable };
    pub const Iface = gee.IteratorIface;
    pub const virtual_methods = struct {
        pub const next = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Iterator.Iface, p_class).f_next.?(gobject.ext.as(Iterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Iterator.Iface, p_class).f_next = @ptrCast(p_implementation);
            }
        };

        pub const has_next = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Iterator.Iface, p_class).f_has_next.?(gobject.ext.as(Iterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Iterator.Iface, p_class).f_has_next = @ptrCast(p_implementation);
            }
        };

        pub const get = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Iterator.Iface, p_class).f_get.?(gobject.ext.as(Iterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Iterator.Iface, p_class).f_get = @ptrCast(p_implementation);
            }
        };

        pub const remove = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(Iterator.Iface, p_class).f_remove.?(gobject.ext.as(Iterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(Iterator.Iface, p_class).f_remove = @ptrCast(p_implementation);
            }
        };

        pub const get_valid = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Iterator.Iface, p_class).f_get_valid.?(gobject.ext.as(Iterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Iterator.Iface, p_class).f_get_valid = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Iterator.Iface, p_class).f_get_read_only.?(gobject.ext.as(Iterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Iterator.Iface, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const valid = struct {
            pub const name = "valid";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_iterator_unfold(p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.UnfoldFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify, p_current: ?*gee.Lazy) *gee.Iterator;
    pub const unfold = gee_iterator_unfold;

    extern fn gee_iterator_concat(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_iters: *gee.Iterator) *gee.Iterator;
    pub const concat = gee_iterator_concat;

    extern fn gee_iterator_next(p_self: *Iterator) c_int;
    pub const next = gee_iterator_next;

    extern fn gee_iterator_has_next(p_self: *Iterator) c_int;
    pub const hasNext = gee_iterator_has_next;

    extern fn gee_iterator_get(p_self: *Iterator) ?*anyopaque;
    pub const get = gee_iterator_get;

    extern fn gee_iterator_remove(p_self: *Iterator) void;
    pub const remove = gee_iterator_remove;

    extern fn gee_iterator_get_valid(p_self: *Iterator) c_int;
    pub const getValid = gee_iterator_get_valid;

    extern fn gee_iterator_get_read_only(p_self: *Iterator) c_int;
    pub const getReadOnly = gee_iterator_get_read_only;

    extern fn gee_iterator_get_type() usize;
    pub const getGObjectType = gee_iterator_get_type;

    extern fn g_object_ref(p_self: *gee.Iterator) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Iterator) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Iterator, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const List = opaque {
    pub const Prerequisites = [_]type{gee.Collection};
    pub const Iface = gee.ListIface;
    pub const virtual_methods = struct {
        pub const list_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.ListIterator {
                return gobject.ext.as(List.Iface, p_class).f_list_iterator.?(gobject.ext.as(List, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.ListIterator) void {
                gobject.ext.as(List.Iface, p_class).f_list_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) ?*anyopaque {
                return gobject.ext.as(List.Iface, p_class).f_get.?(gobject.ext.as(List, p_self), p_index);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(List.Iface, p_class).f_get = @ptrCast(p_implementation);
            }
        };

        pub const set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) void {
                return gobject.ext.as(List.Iface, p_class).f_set.?(gobject.ext.as(List, p_self), p_index, p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(List.Iface, p_class).f_set = @ptrCast(p_implementation);
            }
        };

        pub const index_of = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(List.Iface, p_class).f_index_of.?(gobject.ext.as(List, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(List.Iface, p_class).f_index_of = @ptrCast(p_implementation);
            }
        };

        pub const insert = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) void {
                return gobject.ext.as(List.Iface, p_class).f_insert.?(gobject.ext.as(List, p_self), p_index, p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(List.Iface, p_class).f_insert = @ptrCast(p_implementation);
            }
        };

        pub const remove_at = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) ?*anyopaque {
                return gobject.ext.as(List.Iface, p_class).f_remove_at.?(gobject.ext.as(List, p_self), p_index);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(List.Iface, p_class).f_remove_at = @ptrCast(p_implementation);
            }
        };

        pub const slice = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_start: c_int, p_stop: c_int) ?*gee.List {
                return gobject.ext.as(List.Iface, p_class).f_slice.?(gobject.ext.as(List, p_self), p_start, p_stop);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_start: c_int, p_stop: c_int) callconv(.c) ?*gee.List) void {
                gobject.ext.as(List.Iface, p_class).f_slice = @ptrCast(p_implementation);
            }
        };

        pub const first = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(List.Iface, p_class).f_first.?(gobject.ext.as(List, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(List.Iface, p_class).f_first = @ptrCast(p_implementation);
            }
        };

        pub const last = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(List.Iface, p_class).f_last.?(gobject.ext.as(List, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(List.Iface, p_class).f_last = @ptrCast(p_implementation);
            }
        };

        pub const insert_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_collection: *gee.Collection) void {
                return gobject.ext.as(List.Iface, p_class).f_insert_all.?(gobject.ext.as(List, p_self), p_index, p_collection);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_index: c_int, p_collection: *gee.Collection) callconv(.c) void) void {
                gobject.ext.as(List.Iface, p_class).f_insert_all = @ptrCast(p_implementation);
            }
        };

        pub const sort = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) void {
                return gobject.ext.as(List.Iface, p_class).f_sort.?(gobject.ext.as(List, p_self), p_compare_func, p_compare_func_target, p_compare_func_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) void) void {
                gobject.ext.as(List.Iface, p_class).f_sort = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.List {
                return gobject.ext.as(List.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(List, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.List) void {
                gobject.ext.as(List.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.List;
        };
    };

    pub const signals = struct {};

    extern fn gee_list_empty(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.List;
    pub const empty = gee_list_empty;

    extern fn gee_list_list_iterator(p_self: *List) *gee.ListIterator;
    pub const listIterator = gee_list_list_iterator;

    extern fn gee_list_get(p_self: *List, p_index: c_int) ?*anyopaque;
    pub const get = gee_list_get;

    extern fn gee_list_set(p_self: *List, p_index: c_int, p_item: ?*anyopaque) void;
    pub const set = gee_list_set;

    extern fn gee_list_index_of(p_self: *List, p_item: ?*anyopaque) c_int;
    pub const indexOf = gee_list_index_of;

    extern fn gee_list_insert(p_self: *List, p_index: c_int, p_item: ?*anyopaque) void;
    pub const insert = gee_list_insert;

    extern fn gee_list_remove_at(p_self: *List, p_index: c_int) ?*anyopaque;
    pub const removeAt = gee_list_remove_at;

    extern fn gee_list_slice(p_self: *List, p_start: c_int, p_stop: c_int) ?*gee.List;
    pub const slice = gee_list_slice;

    extern fn gee_list_first(p_self: *List) ?*anyopaque;
    pub const first = gee_list_first;

    extern fn gee_list_last(p_self: *List) ?*anyopaque;
    pub const last = gee_list_last;

    extern fn gee_list_insert_all(p_self: *List, p_index: c_int, p_collection: *gee.Collection) void;
    pub const insertAll = gee_list_insert_all;

    extern fn gee_list_sort(p_self: *List, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) void;
    pub const sort = gee_list_sort;

    extern fn gee_list_get_read_only_view(p_self: *List) *gee.List;
    pub const getReadOnlyView = gee_list_get_read_only_view;

    extern fn gee_list_get_type() usize;
    pub const getGObjectType = gee_list_get_type;

    extern fn g_object_ref(p_self: *gee.List) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.List) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *List, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ListIterator = opaque {
    pub const Prerequisites = [_]type{gee.Iterator};
    pub const Iface = gee.ListIteratorIface;
    pub const virtual_methods = struct {
        pub const set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) void {
                return gobject.ext.as(ListIterator.Iface, p_class).f_set.?(gobject.ext.as(ListIterator, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(ListIterator.Iface, p_class).f_set = @ptrCast(p_implementation);
            }
        };

        pub const add = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) void {
                return gobject.ext.as(ListIterator.Iface, p_class).f_add.?(gobject.ext.as(ListIterator, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(ListIterator.Iface, p_class).f_add = @ptrCast(p_implementation);
            }
        };

        pub const index = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(ListIterator.Iface, p_class).f_index.?(gobject.ext.as(ListIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(ListIterator.Iface, p_class).f_index = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_list_iterator_set(p_self: *ListIterator, p_item: ?*anyopaque) void;
    pub const set = gee_list_iterator_set;

    extern fn gee_list_iterator_add(p_self: *ListIterator, p_item: ?*anyopaque) void;
    pub const add = gee_list_iterator_add;

    extern fn gee_list_iterator_index(p_self: *ListIterator) c_int;
    pub const index = gee_list_iterator_index;

    extern fn gee_list_iterator_get_type() usize;
    pub const getGObjectType = gee_list_iterator_get_type;

    extern fn g_object_ref(p_self: *gee.ListIterator) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.ListIterator) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *ListIterator, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Map = opaque {
    pub const Prerequisites = [_]type{ gobject.Object, gee.Iterable };
    pub const Iface = gee.MapIface;
    pub const virtual_methods = struct {
        pub const has_key = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_has_key.?(gobject.ext.as(Map, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_has_key = @ptrCast(p_implementation);
            }
        };

        pub const has = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_has.?(gobject.ext.as(Map, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_has = @ptrCast(p_implementation);
            }
        };

        pub const get = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(Map.Iface, p_class).f_get.?(gobject.ext.as(Map, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Map.Iface, p_class).f_get = @ptrCast(p_implementation);
            }
        };

        pub const set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) void {
                return gobject.ext.as(Map.Iface, p_class).f_set.?(gobject.ext.as(Map, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(Map.Iface, p_class).f_set = @ptrCast(p_implementation);
            }
        };

        pub const unset = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_unset.?(gobject.ext.as(Map, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_unset = @ptrCast(p_implementation);
            }
        };

        pub const clear = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(Map.Iface, p_class).f_clear.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(Map.Iface, p_class).f_clear = @ptrCast(p_implementation);
            }
        };

        pub const map_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MapIterator {
                return gobject.ext.as(Map.Iface, p_class).f_map_iterator.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MapIterator) void {
                gobject.ext.as(Map.Iface, p_class).f_map_iterator = @ptrCast(p_implementation);
            }
        };

        pub const set_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_map: *gee.Map) void {
                return gobject.ext.as(Map.Iface, p_class).f_set_all.?(gobject.ext.as(Map, p_self), p_map);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_map: *gee.Map) callconv(.c) void) void {
                gobject.ext.as(Map.Iface, p_class).f_set_all = @ptrCast(p_implementation);
            }
        };

        pub const unset_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_map: *gee.Map) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_unset_all.?(gobject.ext.as(Map, p_self), p_map);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_map: *gee.Map) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_unset_all = @ptrCast(p_implementation);
            }
        };

        pub const has_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_map: *gee.Map) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_has_all.?(gobject.ext.as(Map, p_self), p_map);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_map: *gee.Map) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_has_all = @ptrCast(p_implementation);
            }
        };

        pub const get_size = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_get_size.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_get_size = @ptrCast(p_implementation);
            }
        };

        pub const get_is_empty = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_get_is_empty.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_get_is_empty = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Map.Iface, p_class).f_get_read_only.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Map.Iface, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };

        pub const get_keys = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(Map.Iface, p_class).f_get_keys.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(Map.Iface, p_class).f_get_keys = @ptrCast(p_implementation);
            }
        };

        pub const get_values = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Collection {
                return gobject.ext.as(Map.Iface, p_class).f_get_values.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Collection) void {
                gobject.ext.as(Map.Iface, p_class).f_get_values = @ptrCast(p_implementation);
            }
        };

        pub const get_entries = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(Map.Iface, p_class).f_get_entries.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(Map.Iface, p_class).f_get_entries = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Map {
                return gobject.ext.as(Map.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(Map, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Map) void {
                gobject.ext.as(Map.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const size = struct {
            pub const name = "size";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };

        pub const keys = struct {
            pub const name = "keys";

            pub const Type = ?**gee.Set;
        };

        pub const values = struct {
            pub const name = "values";

            pub const Type = ?**gee.Collection;
        };

        pub const entries = struct {
            pub const name = "entries";

            pub const Type = ?**gee.Set;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.Map;
        };
    };

    pub const signals = struct {};

    extern fn gee_map_empty(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify) *gee.Map;
    pub const empty = gee_map_empty;

    extern fn gee_map_has_key(p_self: *Map, p_key: ?*anyopaque) c_int;
    pub const hasKey = gee_map_has_key;

    extern fn gee_map_contains(p_self: *Map, p_key: ?*anyopaque) c_int;
    pub const contains = gee_map_contains;

    extern fn gee_map_has(p_self: *Map, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int;
    pub const has = gee_map_has;

    extern fn gee_map_get(p_self: *Map, p_key: ?*anyopaque) ?*anyopaque;
    pub const get = gee_map_get;

    extern fn gee_map_set(p_self: *Map, p_key: ?*anyopaque, p_value: ?*anyopaque) void;
    pub const set = gee_map_set;

    extern fn gee_map_unset(p_self: *Map, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int;
    pub const unset = gee_map_unset;

    extern fn gee_map_remove(p_self: *Map, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int;
    pub const remove = gee_map_remove;

    extern fn gee_map_clear(p_self: *Map) void;
    pub const clear = gee_map_clear;

    extern fn gee_map_map_iterator(p_self: *Map) *gee.MapIterator;
    pub const mapIterator = gee_map_map_iterator;

    extern fn gee_map_set_all(p_self: *Map, p_map: *gee.Map) void;
    pub const setAll = gee_map_set_all;

    extern fn gee_map_unset_all(p_self: *Map, p_map: *gee.Map) c_int;
    pub const unsetAll = gee_map_unset_all;

    extern fn gee_map_remove_all(p_self: *Map, p_map: *gee.Map) c_int;
    pub const removeAll = gee_map_remove_all;

    extern fn gee_map_has_all(p_self: *Map, p_map: *gee.Map) c_int;
    pub const hasAll = gee_map_has_all;

    extern fn gee_map_contains_all(p_self: *Map, p_map: *gee.Map) c_int;
    pub const containsAll = gee_map_contains_all;

    extern fn gee_map_get_size(p_self: *Map) c_int;
    pub const getSize = gee_map_get_size;

    extern fn gee_map_get_is_empty(p_self: *Map) c_int;
    pub const getIsEmpty = gee_map_get_is_empty;

    extern fn gee_map_get_read_only(p_self: *Map) c_int;
    pub const getReadOnly = gee_map_get_read_only;

    extern fn gee_map_get_keys(p_self: *Map) *gee.Set;
    pub const getKeys = gee_map_get_keys;

    extern fn gee_map_get_values(p_self: *Map) *gee.Collection;
    pub const getValues = gee_map_get_values;

    extern fn gee_map_get_entries(p_self: *Map) *gee.Set;
    pub const getEntries = gee_map_get_entries;

    extern fn gee_map_get_read_only_view(p_self: *Map) *gee.Map;
    pub const getReadOnlyView = gee_map_get_read_only_view;

    extern fn gee_map_get_key_type(p_self: *Map) usize;
    pub const getKeyType = gee_map_get_key_type;

    extern fn gee_map_get_value_type(p_self: *Map) usize;
    pub const getValueType = gee_map_get_value_type;

    extern fn gee_map_get_type() usize;
    pub const getGObjectType = gee_map_get_type;

    extern fn g_object_ref(p_self: *gee.Map) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Map) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Map, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MapIterator = opaque {
    pub const Prerequisites = [_]type{gobject.Object};
    pub const Iface = gee.MapIteratorIface;
    pub const virtual_methods = struct {
        pub const next = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MapIterator.Iface, p_class).f_next.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_next = @ptrCast(p_implementation);
            }
        };

        pub const has_next = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MapIterator.Iface, p_class).f_has_next.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_has_next = @ptrCast(p_implementation);
            }
        };

        pub const get_key = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(MapIterator.Iface, p_class).f_get_key.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_get_key = @ptrCast(p_implementation);
            }
        };

        pub const get_value = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(MapIterator.Iface, p_class).f_get_value.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_get_value = @ptrCast(p_implementation);
            }
        };

        pub const set_value = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_value: ?*anyopaque) void {
                return gobject.ext.as(MapIterator.Iface, p_class).f_set_value.?(gobject.ext.as(MapIterator, p_self), p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_value: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_set_value = @ptrCast(p_implementation);
            }
        };

        pub const unset = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(MapIterator.Iface, p_class).f_unset.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_unset = @ptrCast(p_implementation);
            }
        };

        pub const fold = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldMapFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(MapIterator.Iface, p_class).f_fold.?(gobject.ext.as(MapIterator, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target, p_seed);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldMapFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_fold = @ptrCast(p_implementation);
            }
        };

        pub const foreach = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallMapFunc, p_f_target: ?*anyopaque) c_int {
                return gobject.ext.as(MapIterator.Iface, p_class).f_foreach.?(gobject.ext.as(MapIterator, p_self), p_f, p_f_target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallMapFunc, p_f_target: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_foreach = @ptrCast(p_implementation);
            }
        };

        pub const get_valid = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MapIterator.Iface, p_class).f_get_valid.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_get_valid = @ptrCast(p_implementation);
            }
        };

        pub const get_mutable = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MapIterator.Iface, p_class).f_get_mutable.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_get_mutable = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MapIterator.Iface, p_class).f_get_read_only.?(gobject.ext.as(MapIterator, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MapIterator.Iface, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const valid = struct {
            pub const name = "valid";

            pub const Type = c_int;
        };

        pub const mutable = struct {
            pub const name = "mutable";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_map_iterator_next(p_self: *MapIterator) c_int;
    pub const next = gee_map_iterator_next;

    extern fn gee_map_iterator_has_next(p_self: *MapIterator) c_int;
    pub const hasNext = gee_map_iterator_has_next;

    extern fn gee_map_iterator_get_key(p_self: *MapIterator) ?*anyopaque;
    pub const getKey = gee_map_iterator_get_key;

    extern fn gee_map_iterator_get_value(p_self: *MapIterator) ?*anyopaque;
    pub const getValue = gee_map_iterator_get_value;

    extern fn gee_map_iterator_set_value(p_self: *MapIterator, p_value: ?*anyopaque) void;
    pub const setValue = gee_map_iterator_set_value;

    extern fn gee_map_iterator_unset(p_self: *MapIterator) void;
    pub const unset = gee_map_iterator_unset;

    extern fn gee_map_iterator_fold(p_self: *MapIterator, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldMapFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) ?*anyopaque;
    pub const fold = gee_map_iterator_fold;

    extern fn gee_map_iterator_foreach(p_self: *MapIterator, p_f: gee.ForallMapFunc, p_f_target: ?*anyopaque) c_int;
    pub const foreach = gee_map_iterator_foreach;

    extern fn gee_map_iterator_get_valid(p_self: *MapIterator) c_int;
    pub const getValid = gee_map_iterator_get_valid;

    extern fn gee_map_iterator_get_mutable(p_self: *MapIterator) c_int;
    pub const getMutable = gee_map_iterator_get_mutable;

    extern fn gee_map_iterator_get_read_only(p_self: *MapIterator) c_int;
    pub const getReadOnly = gee_map_iterator_get_read_only;

    extern fn gee_map_iterator_get_type() usize;
    pub const getGObjectType = gee_map_iterator_get_type;

    extern fn g_object_ref(p_self: *gee.MapIterator) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.MapIterator) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *MapIterator, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MultiMap = opaque {
    pub const Prerequisites = [_]type{gobject.Object};
    pub const Iface = gee.MultiMapIface;
    pub const virtual_methods = struct {
        pub const get_keys = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get_keys.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get_keys = @ptrCast(p_implementation);
            }
        };

        pub const get_all_keys = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MultiSet {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get_all_keys.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MultiSet) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get_all_keys = @ptrCast(p_implementation);
            }
        };

        pub const get_values = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Collection {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get_values.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Collection) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get_values = @ptrCast(p_implementation);
            }
        };

        pub const contains = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) c_int {
                return gobject.ext.as(MultiMap.Iface, p_class).f_contains.?(gobject.ext.as(MultiMap, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_contains = @ptrCast(p_implementation);
            }
        };

        pub const get = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) *gee.Collection {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get.?(gobject.ext.as(MultiMap, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) *gee.Collection) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get = @ptrCast(p_implementation);
            }
        };

        pub const set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) void {
                return gobject.ext.as(MultiMap.Iface, p_class).f_set.?(gobject.ext.as(MultiMap, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) void) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_set = @ptrCast(p_implementation);
            }
        };

        pub const remove = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int {
                return gobject.ext.as(MultiMap.Iface, p_class).f_remove.?(gobject.ext.as(MultiMap, p_self), p_key, p_value);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_remove = @ptrCast(p_implementation);
            }
        };

        pub const remove_all = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) c_int {
                return gobject.ext.as(MultiMap.Iface, p_class).f_remove_all.?(gobject.ext.as(MultiMap, p_self), p_key);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_key: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_remove_all = @ptrCast(p_implementation);
            }
        };

        pub const clear = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) void {
                return gobject.ext.as(MultiMap.Iface, p_class).f_clear.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) void) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_clear = @ptrCast(p_implementation);
            }
        };

        pub const map_iterator = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MapIterator {
                return gobject.ext.as(MultiMap.Iface, p_class).f_map_iterator.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MapIterator) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_map_iterator = @ptrCast(p_implementation);
            }
        };

        pub const get_size = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get_size.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get_size = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get_read_only.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get_read_only = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MultiMap {
                return gobject.ext.as(MultiMap.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(MultiMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MultiMap) void {
                gobject.ext.as(MultiMap.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const size = struct {
            pub const name = "size";

            pub const Type = c_int;
        };

        pub const read_only = struct {
            pub const name = "read-only";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    extern fn gee_multi_map_get_keys(p_self: *MultiMap) *gee.Set;
    pub const getKeys = gee_multi_map_get_keys;

    extern fn gee_multi_map_get_all_keys(p_self: *MultiMap) *gee.MultiSet;
    pub const getAllKeys = gee_multi_map_get_all_keys;

    extern fn gee_multi_map_get_values(p_self: *MultiMap) *gee.Collection;
    pub const getValues = gee_multi_map_get_values;

    extern fn gee_multi_map_contains(p_self: *MultiMap, p_key: ?*anyopaque) c_int;
    pub const contains = gee_multi_map_contains;

    extern fn gee_multi_map_get(p_self: *MultiMap, p_key: ?*anyopaque) *gee.Collection;
    pub const get = gee_multi_map_get;

    extern fn gee_multi_map_set(p_self: *MultiMap, p_key: ?*anyopaque, p_value: ?*anyopaque) void;
    pub const set = gee_multi_map_set;

    extern fn gee_multi_map_remove(p_self: *MultiMap, p_key: ?*anyopaque, p_value: ?*anyopaque) c_int;
    pub const remove = gee_multi_map_remove;

    extern fn gee_multi_map_remove_all(p_self: *MultiMap, p_key: ?*anyopaque) c_int;
    pub const removeAll = gee_multi_map_remove_all;

    extern fn gee_multi_map_clear(p_self: *MultiMap) void;
    pub const clear = gee_multi_map_clear;

    extern fn gee_multi_map_map_iterator(p_self: *MultiMap) *gee.MapIterator;
    pub const mapIterator = gee_multi_map_map_iterator;

    extern fn gee_multi_map_get_size(p_self: *MultiMap) c_int;
    pub const getSize = gee_multi_map_get_size;

    extern fn gee_multi_map_get_read_only(p_self: *MultiMap) c_int;
    pub const getReadOnly = gee_multi_map_get_read_only;

    extern fn gee_multi_map_get_key_type(p_self: *MultiMap) usize;
    pub const getKeyType = gee_multi_map_get_key_type;

    extern fn gee_multi_map_get_value_type(p_self: *MultiMap) usize;
    pub const getValueType = gee_multi_map_get_value_type;

    extern fn gee_multi_map_get_read_only_view(p_self: *MultiMap) *gee.MultiMap;
    pub const getReadOnlyView = gee_multi_map_get_read_only_view;

    extern fn gee_multi_map_get_type() usize;
    pub const getGObjectType = gee_multi_map_get_type;

    extern fn g_object_ref(p_self: *gee.MultiMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.MultiMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *MultiMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MultiSet = opaque {
    pub const Prerequisites = [_]type{gee.Collection};
    pub const Iface = gee.MultiSetIface;
    pub const virtual_methods = struct {
        pub const count = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) c_int {
                return gobject.ext.as(MultiSet.Iface, p_class).f_count.?(gobject.ext.as(MultiSet, p_self), p_item);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_item: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(MultiSet.Iface, p_class).f_count = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.MultiSet {
                return gobject.ext.as(MultiSet.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(MultiSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.MultiSet) void {
                gobject.ext.as(MultiSet.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_multi_set_empty(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.Set;
    pub const empty = gee_multi_set_empty;

    extern fn gee_multi_set_count(p_self: *MultiSet, p_item: ?*anyopaque) c_int;
    pub const count = gee_multi_set_count;

    extern fn gee_multi_set_get_read_only_view(p_self: *MultiSet) *gee.MultiSet;
    pub const getReadOnlyView = gee_multi_set_get_read_only_view;

    extern fn gee_multi_set_get_type() usize;
    pub const getGObjectType = gee_multi_set_get_type;

    extern fn g_object_ref(p_self: *gee.MultiSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.MultiSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *MultiSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Queue = opaque {
    pub const Prerequisites = [_]type{gee.Collection};
    pub const Iface = gee.QueueIface;
    pub const virtual_methods = struct {
        pub const offer = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) c_int {
                return gobject.ext.as(Queue.Iface, p_class).f_offer.?(gobject.ext.as(Queue, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Queue.Iface, p_class).f_offer = @ptrCast(p_implementation);
            }
        };

        pub const peek = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Queue.Iface, p_class).f_peek.?(gobject.ext.as(Queue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Queue.Iface, p_class).f_peek = @ptrCast(p_implementation);
            }
        };

        pub const poll = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(Queue.Iface, p_class).f_poll.?(gobject.ext.as(Queue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Queue.Iface, p_class).f_poll = @ptrCast(p_implementation);
            }
        };

        pub const drain = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_recipient: *gee.Collection, p_amount: c_int) c_int {
                return gobject.ext.as(Queue.Iface, p_class).f_drain.?(gobject.ext.as(Queue, p_self), p_recipient, p_amount);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_recipient: *gee.Collection, p_amount: c_int) callconv(.c) c_int) void {
                gobject.ext.as(Queue.Iface, p_class).f_drain = @ptrCast(p_implementation);
            }
        };

        pub const get_capacity = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Queue.Iface, p_class).f_get_capacity.?(gobject.ext.as(Queue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Queue.Iface, p_class).f_get_capacity = @ptrCast(p_implementation);
            }
        };

        pub const get_remaining_capacity = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Queue.Iface, p_class).f_get_remaining_capacity.?(gobject.ext.as(Queue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Queue.Iface, p_class).f_get_remaining_capacity = @ptrCast(p_implementation);
            }
        };

        pub const get_is_full = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) c_int {
                return gobject.ext.as(Queue.Iface, p_class).f_get_is_full.?(gobject.ext.as(Queue, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) c_int) void {
                gobject.ext.as(Queue.Iface, p_class).f_get_is_full = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const capacity = struct {
            pub const name = "capacity";

            pub const Type = c_int;
        };

        pub const remaining_capacity = struct {
            pub const name = "remaining-capacity";

            pub const Type = c_int;
        };

        pub const is_full = struct {
            pub const name = "is-full";

            pub const Type = c_int;
        };
    };

    pub const signals = struct {};

    pub const UNBOUNDED_CAPACITY = -1;
    extern fn gee_queue_offer(p_self: *Queue, p_element: ?*anyopaque) c_int;
    pub const offer = gee_queue_offer;

    extern fn gee_queue_peek(p_self: *Queue) ?*anyopaque;
    pub const peek = gee_queue_peek;

    extern fn gee_queue_poll(p_self: *Queue) ?*anyopaque;
    pub const poll = gee_queue_poll;

    extern fn gee_queue_drain(p_self: *Queue, p_recipient: *gee.Collection, p_amount: c_int) c_int;
    pub const drain = gee_queue_drain;

    extern fn gee_queue_get_capacity(p_self: *Queue) c_int;
    pub const getCapacity = gee_queue_get_capacity;

    extern fn gee_queue_get_remaining_capacity(p_self: *Queue) c_int;
    pub const getRemainingCapacity = gee_queue_get_remaining_capacity;

    extern fn gee_queue_get_is_full(p_self: *Queue) c_int;
    pub const getIsFull = gee_queue_get_is_full;

    extern fn gee_queue_get_type() usize;
    pub const getGObjectType = gee_queue_get_type;

    extern fn g_object_ref(p_self: *gee.Queue) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Queue) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Queue, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Set = opaque {
    pub const Prerequisites = [_]type{gee.Collection};
    pub const Iface = gee.SetIface;
    pub const virtual_methods = struct {
        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.Set {
                return gobject.ext.as(Set.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(Set, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.Set) void {
                gobject.ext.as(Set.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.Set;
        };
    };

    pub const signals = struct {};

    extern fn gee_set_empty(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.Set;
    pub const empty = gee_set_empty;

    extern fn gee_set_get_read_only_view(p_self: *Set) *gee.Set;
    pub const getReadOnlyView = gee_set_get_read_only_view;

    extern fn gee_set_get_type() usize;
    pub const getGObjectType = gee_set_get_type;

    extern fn g_object_ref(p_self: *gee.Set) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Set) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Set, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const SortedMap = opaque {
    pub const Prerequisites = [_]type{gee.Map};
    pub const Iface = gee.SortedMapIface;
    pub const virtual_methods = struct {
        pub const head_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) *gee.SortedMap {
                return gobject.ext.as(SortedMap.Iface, p_class).f_head_map.?(gobject.ext.as(SortedMap, p_self), p_before);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(SortedMap.Iface, p_class).f_head_map = @ptrCast(p_implementation);
            }
        };

        pub const tail_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) *gee.SortedMap {
                return gobject.ext.as(SortedMap.Iface, p_class).f_tail_map.?(gobject.ext.as(SortedMap, p_self), p_after);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(SortedMap.Iface, p_class).f_tail_map = @ptrCast(p_implementation);
            }
        };

        pub const sub_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque, p_after: ?*anyopaque) *gee.SortedMap {
                return gobject.ext.as(SortedMap.Iface, p_class).f_sub_map.?(gobject.ext.as(SortedMap, p_self), p_before, p_after);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(SortedMap.Iface, p_class).f_sub_map = @ptrCast(p_implementation);
            }
        };

        pub const get_ascending_keys = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedSet {
                return gobject.ext.as(SortedMap.Iface, p_class).f_get_ascending_keys.?(gobject.ext.as(SortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(SortedMap.Iface, p_class).f_get_ascending_keys = @ptrCast(p_implementation);
            }
        };

        pub const get_ascending_entries = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedSet {
                return gobject.ext.as(SortedMap.Iface, p_class).f_get_ascending_entries.?(gobject.ext.as(SortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(SortedMap.Iface, p_class).f_get_ascending_entries = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedMap {
                return gobject.ext.as(SortedMap.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(SortedMap, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedMap) void {
                gobject.ext.as(SortedMap.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const ascending_keys = struct {
            pub const name = "ascending-keys";

            pub const Type = ?**gee.SortedSet;
        };

        pub const ascending_entries = struct {
            pub const name = "ascending-entries";

            pub const Type = ?**gee.SortedSet;
        };

        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.SortedMap;
        };
    };

    pub const signals = struct {};

    extern fn gee_sorted_map_empty(p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify) *gee.Map;
    pub const empty = gee_sorted_map_empty;

    extern fn gee_sorted_map_head_map(p_self: *SortedMap, p_before: ?*anyopaque) *gee.SortedMap;
    pub const headMap = gee_sorted_map_head_map;

    extern fn gee_sorted_map_tail_map(p_self: *SortedMap, p_after: ?*anyopaque) *gee.SortedMap;
    pub const tailMap = gee_sorted_map_tail_map;

    extern fn gee_sorted_map_sub_map(p_self: *SortedMap, p_before: ?*anyopaque, p_after: ?*anyopaque) *gee.SortedMap;
    pub const subMap = gee_sorted_map_sub_map;

    extern fn gee_sorted_map_get_ascending_keys(p_self: *SortedMap) *gee.SortedSet;
    pub const getAscendingKeys = gee_sorted_map_get_ascending_keys;

    extern fn gee_sorted_map_get_ascending_entries(p_self: *SortedMap) *gee.SortedSet;
    pub const getAscendingEntries = gee_sorted_map_get_ascending_entries;

    extern fn gee_sorted_map_get_read_only_view(p_self: *SortedMap) *gee.SortedMap;
    pub const getReadOnlyView = gee_sorted_map_get_read_only_view;

    extern fn gee_sorted_map_get_type() usize;
    pub const getGObjectType = gee_sorted_map_get_type;

    extern fn g_object_ref(p_self: *gee.SortedMap) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.SortedMap) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *SortedMap, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const SortedSet = opaque {
    pub const Prerequisites = [_]type{gee.Set};
    pub const Iface = gee.SortedSetIface;
    pub const virtual_methods = struct {
        pub const first = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(SortedSet.Iface, p_class).f_first.?(gobject.ext.as(SortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_first = @ptrCast(p_implementation);
            }
        };

        pub const last = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) ?*anyopaque {
                return gobject.ext.as(SortedSet.Iface, p_class).f_last.?(gobject.ext.as(SortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_last = @ptrCast(p_implementation);
            }
        };

        pub const iterator_at = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*gee.Iterator {
                return gobject.ext.as(SortedSet.Iface, p_class).f_iterator_at.?(gobject.ext.as(SortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*gee.Iterator) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_iterator_at = @ptrCast(p_implementation);
            }
        };

        pub const lower = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(SortedSet.Iface, p_class).f_lower.?(gobject.ext.as(SortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_lower = @ptrCast(p_implementation);
            }
        };

        pub const higher = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(SortedSet.Iface, p_class).f_higher.?(gobject.ext.as(SortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_higher = @ptrCast(p_implementation);
            }
        };

        pub const floor = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(SortedSet.Iface, p_class).f_floor.?(gobject.ext.as(SortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_floor = @ptrCast(p_implementation);
            }
        };

        pub const ceil = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(SortedSet.Iface, p_class).f_ceil.?(gobject.ext.as(SortedSet, p_self), p_element);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_element: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_ceil = @ptrCast(p_implementation);
            }
        };

        pub const head_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) *gee.SortedSet {
                return gobject.ext.as(SortedSet.Iface, p_class).f_head_set.?(gobject.ext.as(SortedSet, p_self), p_before);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_before: ?*anyopaque) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_head_set = @ptrCast(p_implementation);
            }
        };

        pub const tail_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) *gee.SortedSet {
                return gobject.ext.as(SortedSet.Iface, p_class).f_tail_set.?(gobject.ext.as(SortedSet, p_self), p_after);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_after: ?*anyopaque) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_tail_set = @ptrCast(p_implementation);
            }
        };

        pub const sub_set = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_from: ?*anyopaque, p_to: ?*anyopaque) *gee.SortedSet {
                return gobject.ext.as(SortedSet.Iface, p_class).f_sub_set.?(gobject.ext.as(SortedSet, p_self), p_from, p_to);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_from: ?*anyopaque, p_to: ?*anyopaque) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_sub_set = @ptrCast(p_implementation);
            }
        };

        pub const get_read_only_view = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) *gee.SortedSet {
                return gobject.ext.as(SortedSet.Iface, p_class).f_get_read_only_view.?(gobject.ext.as(SortedSet, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) *gee.SortedSet) void {
                gobject.ext.as(SortedSet.Iface, p_class).f_get_read_only_view = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {
        pub const read_only_view = struct {
            pub const name = "read-only-view";

            pub const Type = ?**gee.SortedSet;
        };
    };

    pub const signals = struct {};

    extern fn gee_sorted_set_empty(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify) *gee.SortedSet;
    pub const empty = gee_sorted_set_empty;

    extern fn gee_sorted_set_first(p_self: *SortedSet) ?*anyopaque;
    pub const first = gee_sorted_set_first;

    extern fn gee_sorted_set_last(p_self: *SortedSet) ?*anyopaque;
    pub const last = gee_sorted_set_last;

    extern fn gee_sorted_set_iterator_at(p_self: *SortedSet, p_element: ?*anyopaque) ?*gee.Iterator;
    pub const iteratorAt = gee_sorted_set_iterator_at;

    extern fn gee_sorted_set_lower(p_self: *SortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const lower = gee_sorted_set_lower;

    extern fn gee_sorted_set_higher(p_self: *SortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const higher = gee_sorted_set_higher;

    extern fn gee_sorted_set_floor(p_self: *SortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const floor = gee_sorted_set_floor;

    extern fn gee_sorted_set_ceil(p_self: *SortedSet, p_element: ?*anyopaque) ?*anyopaque;
    pub const ceil = gee_sorted_set_ceil;

    extern fn gee_sorted_set_head_set(p_self: *SortedSet, p_before: ?*anyopaque) *gee.SortedSet;
    pub const headSet = gee_sorted_set_head_set;

    extern fn gee_sorted_set_tail_set(p_self: *SortedSet, p_after: ?*anyopaque) *gee.SortedSet;
    pub const tailSet = gee_sorted_set_tail_set;

    extern fn gee_sorted_set_sub_set(p_self: *SortedSet, p_from: ?*anyopaque, p_to: ?*anyopaque) *gee.SortedSet;
    pub const subSet = gee_sorted_set_sub_set;

    extern fn gee_sorted_set_get_read_only_view(p_self: *SortedSet) *gee.SortedSet;
    pub const getReadOnlyView = gee_sorted_set_get_read_only_view;

    extern fn gee_sorted_set_get_type() usize;
    pub const getGObjectType = gee_sorted_set_get_type;

    extern fn g_object_ref(p_self: *gee.SortedSet) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.SortedSet) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *SortedSet, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const Traversable = opaque {
    pub const Prerequisites = [_]type{gobject.Object};
    pub const Iface = gee.TraversableIface;
    pub const virtual_methods = struct {
        pub const foreach = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) c_int {
                return gobject.ext.as(Traversable.Iface, p_class).f_foreach.?(gobject.ext.as(Traversable, p_self), p_f, p_f_target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) callconv(.c) c_int) void {
                gobject.ext.as(Traversable.Iface, p_class).f_foreach = @ptrCast(p_implementation);
            }
        };

        pub const stream = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_stream.?(gobject.ext.as(Traversable, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target, p_f_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_stream = @ptrCast(p_implementation);
            }
        };

        pub const fold = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) ?*anyopaque {
                return gobject.ext.as(Traversable.Iface, p_class).f_fold.?(gobject.ext.as(Traversable, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target, p_seed);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Traversable.Iface, p_class).f_fold = @ptrCast(p_implementation);
            }
        };

        pub const map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.MapFunc, p_f_target: ?*anyopaque) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_map.?(gobject.ext.as(Traversable, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.MapFunc, p_f_target: ?*anyopaque) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_map = @ptrCast(p_implementation);
            }
        };

        pub const scan = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_scan.?(gobject.ext.as(Traversable, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target, p_seed);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_scan = @ptrCast(p_implementation);
            }
        };

        pub const filter = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_filter.?(gobject.ext.as(Traversable, p_self), p_pred, p_pred_target, p_pred_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_filter = @ptrCast(p_implementation);
            }
        };

        pub const chop = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_offset: c_int, p_length: c_int) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_chop.?(gobject.ext.as(Traversable, p_self), p_offset, p_length);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_offset: c_int, p_length: c_int) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_chop = @ptrCast(p_implementation);
            }
        };

        pub const flat_map = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FlatMapFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_flat_map.?(gobject.ext.as(Traversable, p_self), p_a_type, p_a_dup_func, p_a_destroy_func, p_f, p_f_target, p_f_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FlatMapFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_flat_map = @ptrCast(p_implementation);
            }
        };

        pub const tee = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_forks: c_uint, p_result_length1: *c_int) [*]*gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_tee.?(gobject.ext.as(Traversable, p_self), p_forks, p_result_length1);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_forks: c_uint, p_result_length1: *c_int) callconv(.c) [*]*gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_tee = @ptrCast(p_implementation);
            }
        };

        pub const first_match = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) ?*anyopaque {
                return gobject.ext.as(Traversable.Iface, p_class).f_first_match.?(gobject.ext.as(Traversable, p_self), p_pred, p_pred_target, p_pred_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Traversable.Iface, p_class).f_first_match = @ptrCast(p_implementation);
            }
        };

        pub const any_match = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) c_int {
                return gobject.ext.as(Traversable.Iface, p_class).f_any_match.?(gobject.ext.as(Traversable, p_self), p_pred, p_pred_target, p_pred_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) c_int) void {
                gobject.ext.as(Traversable.Iface, p_class).f_any_match = @ptrCast(p_implementation);
            }
        };

        pub const all_match = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) c_int {
                return gobject.ext.as(Traversable.Iface, p_class).f_all_match.?(gobject.ext.as(Traversable, p_self), p_pred, p_pred_target, p_pred_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) c_int) void {
                gobject.ext.as(Traversable.Iface, p_class).f_all_match = @ptrCast(p_implementation);
            }
        };

        pub const max = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) ?*anyopaque {
                return gobject.ext.as(Traversable.Iface, p_class).f_max.?(gobject.ext.as(Traversable, p_self), p_compare, p_compare_target, p_compare_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Traversable.Iface, p_class).f_max = @ptrCast(p_implementation);
            }
        };

        pub const min = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) ?*anyopaque {
                return gobject.ext.as(Traversable.Iface, p_class).f_min.?(gobject.ext.as(Traversable, p_self), p_compare, p_compare_target, p_compare_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) ?*anyopaque) void {
                gobject.ext.as(Traversable.Iface, p_class).f_min = @ptrCast(p_implementation);
            }
        };

        pub const order_by = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare: ?glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator {
                return gobject.ext.as(Traversable.Iface, p_class).f_order_by.?(gobject.ext.as(Traversable, p_self), p_compare, p_compare_target, p_compare_target_destroy_notify);
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance, p_compare: ?glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator) void {
                gobject.ext.as(Traversable.Iface, p_class).f_order_by = @ptrCast(p_implementation);
            }
        };

        pub const get_element_type = struct {
            pub fn call(p_class: anytype, p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) usize {
                return gobject.ext.as(Traversable.Iface, p_class).f_get_element_type.?(gobject.ext.as(Traversable, p_self));
            }

            pub fn implement(p_class: anytype, p_implementation: *const fn (p_self: *@typeInfo(@TypeOf(p_class)).pointer.child.Instance) callconv(.c) usize) void {
                gobject.ext.as(Traversable.Iface, p_class).f_get_element_type = @ptrCast(p_implementation);
            }
        };
    };

    pub const properties = struct {};

    pub const signals = struct {};

    extern fn gee_traversable_foreach(p_self: *Traversable, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) c_int;
    pub const foreach = gee_traversable_foreach;

    extern fn gee_traversable_stream(p_self: *Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator;
    pub const stream = gee_traversable_stream;

    extern fn gee_traversable_fold(p_self: *Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) ?*anyopaque;
    pub const fold = gee_traversable_fold;

    extern fn gee_traversable_map(p_self: *Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.MapFunc, p_f_target: ?*anyopaque) *gee.Iterator;
    pub const map = gee_traversable_map;

    extern fn gee_traversable_scan(p_self: *Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) *gee.Iterator;
    pub const scan = gee_traversable_scan;

    extern fn gee_traversable_filter(p_self: *Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator;
    pub const filter = gee_traversable_filter;

    extern fn gee_traversable_chop(p_self: *Traversable, p_offset: c_int, p_length: c_int) *gee.Iterator;
    pub const chop = gee_traversable_chop;

    extern fn gee_traversable_flat_map(p_self: *Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FlatMapFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator;
    pub const flatMap = gee_traversable_flat_map;

    extern fn gee_traversable_tee(p_self: *Traversable, p_forks: c_uint, p_result_length1: *c_int) [*]*gee.Iterator;
    pub const tee = gee_traversable_tee;

    extern fn gee_traversable_first_match(p_self: *Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) ?*anyopaque;
    pub const firstMatch = gee_traversable_first_match;

    extern fn gee_traversable_any_match(p_self: *Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) c_int;
    pub const anyMatch = gee_traversable_any_match;

    extern fn gee_traversable_all_match(p_self: *Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) c_int;
    pub const allMatch = gee_traversable_all_match;

    extern fn gee_traversable_max(p_self: *Traversable, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) ?*anyopaque;
    pub const max = gee_traversable_max;

    extern fn gee_traversable_min(p_self: *Traversable, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) ?*anyopaque;
    pub const min = gee_traversable_min;

    extern fn gee_traversable_order_by(p_self: *Traversable, p_compare: ?glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) *gee.Iterator;
    pub const orderBy = gee_traversable_order_by;

    extern fn gee_traversable_get_element_type(p_self: *Traversable) usize;
    pub const getElementType = gee_traversable_get_element_type;

    extern fn gee_traversable_get_type() usize;
    pub const getGObjectType = gee_traversable_get_type;

    extern fn g_object_ref(p_self: *gee.Traversable) void;
    pub const ref = g_object_ref;

    extern fn g_object_unref(p_self: *gee.Traversable) void;
    pub const unref = g_object_unref;

    pub fn as(p_instance: *Traversable, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirListClass = extern struct {
    pub const Instance = gee.AbstractBidirList;

    f_parent_class: gee.AbstractListClass,
    f_bidir_list_iterator: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) *gee.BidirListIterator,
    f_reserved0: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractBidirList) callconv(.c) void,

    pub fn as(p_instance: *AbstractBidirListClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirListPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirSortedSetClass = extern struct {
    pub const Instance = gee.AbstractBidirSortedSet;

    f_parent_class: gee.AbstractSortedSetClass,
    f_bidir_iterator: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) *gee.BidirIterator,
    f_reserved0: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractBidirSortedSet) callconv(.c) void,

    pub fn as(p_instance: *AbstractBidirSortedSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirSortedSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirSortedMapClass = extern struct {
    pub const Instance = gee.AbstractBidirSortedMap;

    f_parent_class: gee.AbstractSortedMapClass,
    f_bidir_map_iterator: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) *gee.BidirMapIterator,
    f_reserved0: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractBidirSortedMap) callconv(.c) void,

    pub fn as(p_instance: *AbstractBidirSortedMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractBidirSortedMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractCollectionClass = extern struct {
    pub const Instance = gee.AbstractCollection;

    f_parent_class: gobject.ObjectClass,
    f_contains: ?*const fn (p_self: *gee.AbstractCollection, p_item: ?*anyopaque) callconv(.c) c_int,
    f_add: ?*const fn (p_self: *gee.AbstractCollection, p_item: ?*anyopaque) callconv(.c) c_int,
    f_remove: ?*const fn (p_self: *gee.AbstractCollection, p_item: ?*anyopaque) callconv(.c) c_int,
    f_clear: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_iterator: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) *gee.Iterator,
    f_foreach: ?*const fn (p_self: *gee.AbstractCollection, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) callconv(.c) c_int,
    f_reserved0: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractCollection) callconv(.c) void,

    pub fn as(p_instance: *AbstractCollectionClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractCollectionPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractListClass = extern struct {
    pub const Instance = gee.AbstractList;

    f_parent_class: gee.AbstractCollectionClass,
    f_list_iterator: ?*const fn (p_self: *gee.AbstractList) callconv(.c) *gee.ListIterator,
    f_get: ?*const fn (p_self: *gee.AbstractList, p_index: c_int) callconv(.c) ?*anyopaque,
    f_set: ?*const fn (p_self: *gee.AbstractList, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void,
    f_index_of: ?*const fn (p_self: *gee.AbstractList, p_item: ?*anyopaque) callconv(.c) c_int,
    f_insert: ?*const fn (p_self: *gee.AbstractList, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void,
    f_remove_at: ?*const fn (p_self: *gee.AbstractList, p_index: c_int) callconv(.c) ?*anyopaque,
    f_slice: ?*const fn (p_self: *gee.AbstractList, p_start: c_int, p_stop: c_int) callconv(.c) ?*gee.List,
    f_reserved0: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractList) callconv(.c) void,

    pub fn as(p_instance: *AbstractListClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractListPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMapClass = extern struct {
    pub const Instance = gee.AbstractMap;

    f_parent_class: gobject.ObjectClass,
    f_has_key: ?*const fn (p_self: *gee.AbstractMap, p_key: ?*anyopaque) callconv(.c) c_int,
    f_has: ?*const fn (p_self: *gee.AbstractMap, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int,
    f_get: ?*const fn (p_self: *gee.AbstractMap, p_key: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_set: ?*const fn (p_self: *gee.AbstractMap, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) void,
    f_unset: ?*const fn (p_self: *gee.AbstractMap, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int,
    f_map_iterator: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) *gee.MapIterator,
    f_clear: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_foreach: ?*const fn (p_self: *gee.AbstractMap, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) callconv(.c) c_int,
    f_stream: ?*const fn (p_self: *gee.AbstractMap, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator,
    f_reserved0: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractMap) callconv(.c) void,

    pub fn as(p_instance: *AbstractMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMultiMapClass = extern struct {
    pub const Instance = gee.AbstractMultiMap;

    f_parent_class: gobject.ObjectClass,
    f_create_value_storage: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) *gee.Collection,
    f_create_multi_key_set: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) *gee.MultiSet,
    f_get_value_equal_func: ?*const fn (p_self: *gee.AbstractMultiMap, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) callconv(.c) gee.EqualDataFunc,
    f_reserved0: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractMultiMap) callconv(.c) void,

    pub fn as(p_instance: *AbstractMultiMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMultiMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMultiSetClass = extern struct {
    pub const Instance = gee.AbstractMultiSet;

    f_parent_class: gee.AbstractCollectionClass,
    f_reserved0: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractMultiSet) callconv(.c) void,

    pub fn as(p_instance: *AbstractMultiSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractMultiSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractQueueClass = extern struct {
    pub const Instance = gee.AbstractQueue;

    f_parent_class: gee.AbstractCollectionClass,
    f_peek: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) ?*anyopaque,
    f_poll: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) ?*anyopaque,
    f_reserved0: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractQueue) callconv(.c) void,

    pub fn as(p_instance: *AbstractQueueClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractQueuePrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSetClass = extern struct {
    pub const Instance = gee.AbstractSet;

    f_parent_class: gee.AbstractCollectionClass,
    f_reserved0: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractSet) callconv(.c) void,

    pub fn as(p_instance: *AbstractSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSortedMapClass = extern struct {
    pub const Instance = gee.AbstractSortedMap;

    f_parent_class: gee.AbstractMapClass,
    f_head_map: ?*const fn (p_self: *gee.AbstractSortedMap, p_before: ?*anyopaque) callconv(.c) *gee.SortedMap,
    f_tail_map: ?*const fn (p_self: *gee.AbstractSortedMap, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap,
    f_sub_map: ?*const fn (p_self: *gee.AbstractSortedMap, p_before: ?*anyopaque, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap,
    f_reserved0: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractSortedMap) callconv(.c) void,

    pub fn as(p_instance: *AbstractSortedMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSortedMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSortedSetClass = extern struct {
    pub const Instance = gee.AbstractSortedSet;

    f_parent_class: gee.AbstractSetClass,
    f_first: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) ?*anyopaque,
    f_last: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) ?*anyopaque,
    f_iterator_at: ?*const fn (p_self: *gee.AbstractSortedSet, p_element: ?*anyopaque) callconv(.c) ?*gee.Iterator,
    f_lower: ?*const fn (p_self: *gee.AbstractSortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_higher: ?*const fn (p_self: *gee.AbstractSortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_floor: ?*const fn (p_self: *gee.AbstractSortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_ceil: ?*const fn (p_self: *gee.AbstractSortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_head_set: ?*const fn (p_self: *gee.AbstractSortedSet, p_before: ?*anyopaque) callconv(.c) *gee.SortedSet,
    f_tail_set: ?*const fn (p_self: *gee.AbstractSortedSet, p_after: ?*anyopaque) callconv(.c) *gee.SortedSet,
    f_sub_set: ?*const fn (p_self: *gee.AbstractSortedSet, p_from: ?*anyopaque, p_to: ?*anyopaque) callconv(.c) *gee.SortedSet,
    f_reserved0: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved1: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved2: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved3: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved4: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved5: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved6: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved7: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved8: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,
    f_reserved9: ?*const fn (p_self: *gee.AbstractSortedSet) callconv(.c) void,

    pub fn as(p_instance: *AbstractSortedSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const AbstractSortedSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ArrayListClass = extern struct {
    pub const Instance = gee.ArrayList;

    f_parent_class: gee.AbstractBidirListClass,

    pub fn as(p_instance: *ArrayListClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ArrayListPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ArrayQueueClass = extern struct {
    pub const Instance = gee.ArrayQueue;

    f_parent_class: gee.AbstractQueueClass,

    pub fn as(p_instance: *ArrayQueueClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ArrayQueuePrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentListClass = extern struct {
    pub const Instance = gee.ConcurrentList;

    f_parent_class: gee.AbstractListClass,

    pub fn as(p_instance: *ConcurrentListClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentListPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentSetClass = extern struct {
    pub const Instance = gee.ConcurrentSet;

    f_parent_class: gee.AbstractSortedSetClass,

    pub fn as(p_instance: *ConcurrentSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMapClass = extern struct {
    pub const Instance = gee.HashMap;

    f_parent_class: gee.AbstractMapClass,

    pub fn as(p_instance: *HashMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMultiMapClass = extern struct {
    pub const Instance = gee.HashMultiMap;

    f_parent_class: gee.AbstractMultiMapClass,

    pub fn as(p_instance: *HashMultiMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMultiMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMultiSetClass = extern struct {
    pub const Instance = gee.HashMultiSet;

    f_parent_class: gee.AbstractMultiSetClass,

    pub fn as(p_instance: *HashMultiSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashMultiSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashSetClass = extern struct {
    pub const Instance = gee.HashSet;

    f_parent_class: gee.AbstractSetClass,

    pub fn as(p_instance: *HashSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HazardPointer = extern struct {
    f__node: ?*gee.HazardPointerNode,

    extern fn gee_hazard_pointer_get_hazard_pointer(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_aptr: ?*anyopaque, p_mask: usize, p_mask_out: *usize) ?*gee.HazardPointer;
    pub const getHazardPointer = gee_hazard_pointer_get_hazard_pointer;

    extern fn gee_hazard_pointer_get_pointer(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_aptr: ?*anyopaque, p_mask: usize, p_mask_out: *usize) ?*anyopaque;
    pub const getPointer = gee_hazard_pointer_get_pointer;

    extern fn gee_hazard_pointer_exchange_hazard_pointer(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_aptr: ?*anyopaque, p_new_ptr: ?*anyopaque, p_mask: usize, p_new_mask: usize, p_old_mask: *usize) ?*gee.HazardPointer;
    pub const exchangeHazardPointer = gee_hazard_pointer_exchange_hazard_pointer;

    extern fn gee_hazard_pointer_set_pointer(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_aptr: ?*anyopaque, p_new_ptr: ?*anyopaque, p_mask: usize, p_new_mask: usize) void;
    pub const setPointer = gee_hazard_pointer_set_pointer;

    extern fn gee_hazard_pointer_exchange_pointer(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_aptr: ?*anyopaque, p_new_ptr: ?*anyopaque, p_mask: usize, p_new_mask: usize, p_old_mask: *usize) ?*anyopaque;
    pub const exchangePointer = gee_hazard_pointer_exchange_pointer;

    extern fn gee_hazard_pointer_compare_and_exchange_pointer(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_aptr: ?*anyopaque, p_old_ptr: ?*anyopaque, p__new_ptr: ?*anyopaque, p_mask: usize, p_old_mask: usize, p_new_mask: usize) c_int;
    pub const compareAndExchangePointer = gee_hazard_pointer_compare_and_exchange_pointer;

    extern fn gee_hazard_pointer_set_default_policy(p_policy: gee.HazardPointerPolicy) void;
    pub const setDefaultPolicy = gee_hazard_pointer_set_default_policy;

    extern fn gee_hazard_pointer_set_thread_exit_policy(p_policy: gee.HazardPointerPolicy) void;
    pub const setThreadExitPolicy = gee_hazard_pointer_set_thread_exit_policy;

    extern fn gee_hazard_pointer_set_release_policy(p_policy: gee.HazardPointerReleasePolicy) c_int;
    pub const setReleasePolicy = gee_hazard_pointer_set_release_policy;

    extern fn gee_hazard_pointer_new(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_ptr: ?*anyopaque) *gee.HazardPointer;
    pub const new = gee_hazard_pointer_new;

    extern fn gee_hazard_pointer_get(p_self: *HazardPointer, p_other_thread: c_int) ?*anyopaque;
    pub const get = gee_hazard_pointer_get;

    extern fn gee_hazard_pointer_release(p_self: *HazardPointer, p_notify: glib.DestroyNotify) void;
    pub const release = gee_hazard_pointer_release;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HazardPointerContext = extern struct {
    f__parent: ?*anyopaque,
    f__to_free: ?*gee.ArrayList,
    f__policy: ?*gee.HazardPointerPolicy,

    extern fn gee_hazard_pointer_context_new(p_policy: ?*gee.HazardPointerPolicy) *gee.HazardPointerContext;
    pub const new = gee_hazard_pointer_context_new;

    extern fn gee_hazard_pointer_context_try_free(p_self: *HazardPointerContext) void;
    pub const tryFree = gee_hazard_pointer_context_try_free;

    extern fn gee_hazard_pointer_context_free_all(p_self: *HazardPointerContext) void;
    pub const freeAll = gee_hazard_pointer_context_free_all;

    extern fn gee_hazard_pointer_context_try_release(p_self: *HazardPointerContext) void;
    pub const tryRelease = gee_hazard_pointer_context_try_release;

    extern fn gee_hazard_pointer_context_release(p_self: *HazardPointerContext) void;
    pub const release = gee_hazard_pointer_context_release;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const LazyClass = extern struct {
    pub const Instance = gee.Lazy;

    f_parent_class: gobject.TypeClass,

    pub fn as(p_instance: *LazyClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const LazyPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const LinkedListClass = extern struct {
    pub const Instance = gee.LinkedList;

    f_parent_class: gee.AbstractBidirListClass,

    pub fn as(p_instance: *LinkedListClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const LinkedListPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const PriorityQueueClass = extern struct {
    pub const Instance = gee.PriorityQueue;

    f_parent_class: gee.AbstractQueueClass,

    pub fn as(p_instance: *PriorityQueueClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const PriorityQueuePrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const PromiseClass = extern struct {
    pub const Instance = gee.Promise;

    f_parent_class: gobject.TypeClass,

    pub fn as(p_instance: *PromiseClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const PromisePrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMapClass = extern struct {
    pub const Instance = gee.TreeMap;

    f_parent_class: gee.AbstractBidirSortedMapClass,

    pub fn as(p_instance: *TreeMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMultiMapClass = extern struct {
    pub const Instance = gee.TreeMultiMap;

    f_parent_class: gee.AbstractMultiMapClass,

    pub fn as(p_instance: *TreeMultiMapClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMultiMapPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMultiSetClass = extern struct {
    pub const Instance = gee.TreeMultiSet;

    f_parent_class: gee.AbstractMultiSetClass,

    pub fn as(p_instance: *TreeMultiSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeMultiSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeSetClass = extern struct {
    pub const Instance = gee.TreeSet;

    f_parent_class: gee.AbstractBidirSortedSetClass,

    pub fn as(p_instance: *TreeSetClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TreeSetPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const UnrolledLinkedListClass = extern struct {
    pub const Instance = gee.UnrolledLinkedList;

    f_parent_class: gee.AbstractBidirListClass,

    pub fn as(p_instance: *UnrolledLinkedListClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const UnrolledLinkedListPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirIteratorIface = extern struct {
    pub const Instance = gee.BidirIterator;

    f_parent_iface: gobject.TypeInterface,
    f_previous: ?*const fn (p_self: *gee.BidirIterator) callconv(.c) c_int,
    f_has_previous: ?*const fn (p_self: *gee.BidirIterator) callconv(.c) c_int,
    f_first: ?*const fn (p_self: *gee.BidirIterator) callconv(.c) c_int,
    f_last: ?*const fn (p_self: *gee.BidirIterator) callconv(.c) c_int,

    pub fn as(p_instance: *BidirIteratorIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirListIface = extern struct {
    pub const Instance = gee.BidirList;

    f_parent_iface: gobject.TypeInterface,
    f_bidir_list_iterator: ?*const fn (p_self: *gee.BidirList) callconv(.c) *gee.BidirListIterator,
    f_get_read_only_view: ?*const fn (p_self: *gee.BidirList) callconv(.c) *gee.BidirList,

    pub fn as(p_instance: *BidirListIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirListIteratorIface = extern struct {
    pub const Instance = gee.BidirListIterator;

    f_parent_iface: gobject.TypeInterface,
    f_insert: ?*const fn (p_self: *gee.BidirListIterator, p_item: ?*anyopaque) callconv(.c) void,

    pub fn as(p_instance: *BidirListIteratorIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirMapIteratorIface = extern struct {
    pub const Instance = gee.BidirMapIterator;

    f_parent_iface: gobject.TypeInterface,
    f_previous: ?*const fn (p_self: *gee.BidirMapIterator) callconv(.c) c_int,
    f_has_previous: ?*const fn (p_self: *gee.BidirMapIterator) callconv(.c) c_int,
    f_first: ?*const fn (p_self: *gee.BidirMapIterator) callconv(.c) c_int,
    f_last: ?*const fn (p_self: *gee.BidirMapIterator) callconv(.c) c_int,

    pub fn as(p_instance: *BidirMapIteratorIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirSortedSetIface = extern struct {
    pub const Instance = gee.BidirSortedSet;

    f_parent_iface: gobject.TypeInterface,
    f_bidir_iterator: ?*const fn (p_self: *gee.BidirSortedSet) callconv(.c) *gee.BidirIterator,
    f_get_read_only_view: ?*const fn (p_self: *gee.BidirSortedSet) callconv(.c) *gee.BidirSortedSet,

    pub fn as(p_instance: *BidirSortedSetIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const BidirSortedMapIface = extern struct {
    pub const Instance = gee.BidirSortedMap;

    f_parent_iface: gobject.TypeInterface,
    f_bidir_map_iterator: ?*const fn (p_self: *gee.BidirSortedMap) callconv(.c) *gee.BidirMapIterator,
    f_get_read_only_view: ?*const fn (p_self: *gee.BidirSortedMap) callconv(.c) *gee.BidirSortedMap,

    pub fn as(p_instance: *BidirSortedMapIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const CollectionIface = extern struct {
    pub const Instance = gee.Collection;

    f_parent_iface: gobject.TypeInterface,
    f_contains: ?*const fn (p_self: *gee.Collection, p_item: ?*anyopaque) callconv(.c) c_int,
    f_add: ?*const fn (p_self: *gee.Collection, p_item: ?*anyopaque) callconv(.c) c_int,
    f_remove: ?*const fn (p_self: *gee.Collection, p_item: ?*anyopaque) callconv(.c) c_int,
    f_clear: ?*const fn (p_self: *gee.Collection) callconv(.c) void,
    f_add_all: ?*const fn (p_self: *gee.Collection, p_collection: *gee.Collection) callconv(.c) c_int,
    f_contains_all: ?*const fn (p_self: *gee.Collection, p_collection: *gee.Collection) callconv(.c) c_int,
    f_remove_all: ?*const fn (p_self: *gee.Collection, p_collection: *gee.Collection) callconv(.c) c_int,
    f_retain_all: ?*const fn (p_self: *gee.Collection, p_collection: *gee.Collection) callconv(.c) c_int,
    f_to_array: ?*const fn (p_self: *gee.Collection, p_result_length1: *c_int) callconv(.c) [*]*anyopaque,
    f_add_all_array: ?*const fn (p_self: *gee.Collection, p_array: [*]*anyopaque, p_array_length1: c_int) callconv(.c) c_int,
    f_contains_all_array: ?*const fn (p_self: *gee.Collection, p_array: [*]*anyopaque, p_array_length1: c_int) callconv(.c) c_int,
    f_remove_all_array: ?*const fn (p_self: *gee.Collection, p_array: [*]*anyopaque, p_array_length1: c_int) callconv(.c) c_int,
    f_add_all_iterator: ?*const fn (p_self: *gee.Collection, p_iter: *gee.Iterator) callconv(.c) c_int,
    f_contains_all_iterator: ?*const fn (p_self: *gee.Collection, p_iter: *gee.Iterator) callconv(.c) c_int,
    f_remove_all_iterator: ?*const fn (p_self: *gee.Collection, p_iter: *gee.Iterator) callconv(.c) c_int,
    f_get_size: ?*const fn (p_self: *gee.Collection) callconv(.c) c_int,
    f_get_is_empty: ?*const fn (p_self: *gee.Collection) callconv(.c) c_int,
    f_get_read_only: ?*const fn (p_self: *gee.Collection) callconv(.c) c_int,
    f_get_read_only_view: ?*const fn (p_self: *gee.Collection) callconv(.c) *gee.Collection,

    pub fn as(p_instance: *CollectionIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ComparableIface = extern struct {
    pub const Instance = gee.Comparable;

    f_parent_iface: gobject.TypeInterface,
    f_compare_to: ?*const fn (p_self: *gee.Comparable, p_object: ?*anyopaque) callconv(.c) c_int,

    pub fn as(p_instance: *ComparableIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const DequeIface = extern struct {
    pub const Instance = gee.Deque;

    f_parent_iface: gobject.TypeInterface,
    f_offer_head: ?*const fn (p_self: *gee.Deque, p_element: ?*anyopaque) callconv(.c) c_int,
    f_peek_head: ?*const fn (p_self: *gee.Deque) callconv(.c) ?*anyopaque,
    f_poll_head: ?*const fn (p_self: *gee.Deque) callconv(.c) ?*anyopaque,
    f_drain_head: ?*const fn (p_self: *gee.Deque, p_recipient: *gee.Collection, p_amount: c_int) callconv(.c) c_int,
    f_offer_tail: ?*const fn (p_self: *gee.Deque, p_element: ?*anyopaque) callconv(.c) c_int,
    f_peek_tail: ?*const fn (p_self: *gee.Deque) callconv(.c) ?*anyopaque,
    f_poll_tail: ?*const fn (p_self: *gee.Deque) callconv(.c) ?*anyopaque,
    f_drain_tail: ?*const fn (p_self: *gee.Deque, p_recipient: *gee.Collection, p_amount: c_int) callconv(.c) c_int,

    pub fn as(p_instance: *DequeIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const FutureIface = extern struct {
    pub const Instance = gee.Future;

    f_parent_iface: gobject.TypeInterface,
    f_wait: ?*const fn (p_self: *gee.Future, p_error: ?*?*glib.Error) callconv(.c) ?*anyopaque,
    f_wait_until: ?*const fn (p_self: *gee.Future, p_end_time: i64, p_value: ?*anyopaque, p_error: ?*?*glib.Error) callconv(.c) c_int,
    f_wait_async: ?*const fn (p_self: *gee.Future, p__callback_: ?gio.AsyncReadyCallback, p__callback__target: ?*anyopaque) callconv(.c) void,
    f_wait_finish: ?*const fn (p_self: *gee.Future, p__res_: *gio.AsyncResult, p_error: ?*?*glib.Error) callconv(.c) ?*anyopaque,
    f_map: ?*const fn (p_self: *gee.Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.MapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Future,
    f_light_map: ?*const fn (p_self: *gee.Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Future,
    f_light_map_broken: ?*const fn (p_self: *gee.Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.LightMapFunc, p_func_target: ?*anyopaque) callconv(.c) *gee.Future,
    f_zip: ?*const fn (p_self: *gee.Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_b_type: usize, p_b_dup_func: gobject.BoxedCopyFunc, p_b_destroy_func: glib.DestroyNotify, p_zip_func: gee.Future.ZipFunc, p_zip_func_target: ?*anyopaque, p_second: *gee.Future) callconv(.c) *gee.Future,
    f_flat_map: ?*const fn (p_self: *gee.Future, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_func: gee.Future.FlatMapFunc, p_func_target: ?*anyopaque, p_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Future,
    f_get_value: ?*const fn (p_self: *gee.Future) callconv(.c) ?*anyopaque,
    f_get_ready: ?*const fn (p_self: *gee.Future) callconv(.c) c_int,
    f_get_exception: ?*const fn (p_self: *gee.Future) callconv(.c) ?*glib.Error,

    pub fn as(p_instance: *FutureIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HashableIface = extern struct {
    pub const Instance = gee.Hashable;

    f_parent_iface: gobject.TypeInterface,
    f_hash: ?*const fn (p_self: *gee.Hashable) callconv(.c) c_uint,
    f_equal_to: ?*const fn (p_self: *gee.Hashable, p_object: ?*anyopaque) callconv(.c) c_int,

    pub fn as(p_instance: *HashableIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const IterableIface = extern struct {
    pub const Instance = gee.Iterable;

    f_parent_iface: gobject.TypeInterface,
    f_iterator: ?*const fn (p_self: *gee.Iterable) callconv(.c) *gee.Iterator,

    pub fn as(p_instance: *IterableIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const IteratorIface = extern struct {
    pub const Instance = gee.Iterator;

    f_parent_iface: gobject.TypeInterface,
    f_next: ?*const fn (p_self: *gee.Iterator) callconv(.c) c_int,
    f_has_next: ?*const fn (p_self: *gee.Iterator) callconv(.c) c_int,
    f_get: ?*const fn (p_self: *gee.Iterator) callconv(.c) ?*anyopaque,
    f_remove: ?*const fn (p_self: *gee.Iterator) callconv(.c) void,
    f_get_valid: ?*const fn (p_self: *gee.Iterator) callconv(.c) c_int,
    f_get_read_only: ?*const fn (p_self: *gee.Iterator) callconv(.c) c_int,

    pub fn as(p_instance: *IteratorIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ListIface = extern struct {
    pub const Instance = gee.List;

    f_parent_iface: gobject.TypeInterface,
    f_list_iterator: ?*const fn (p_self: *gee.List) callconv(.c) *gee.ListIterator,
    f_get: ?*const fn (p_self: *gee.List, p_index: c_int) callconv(.c) ?*anyopaque,
    f_set: ?*const fn (p_self: *gee.List, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void,
    f_index_of: ?*const fn (p_self: *gee.List, p_item: ?*anyopaque) callconv(.c) c_int,
    f_insert: ?*const fn (p_self: *gee.List, p_index: c_int, p_item: ?*anyopaque) callconv(.c) void,
    f_remove_at: ?*const fn (p_self: *gee.List, p_index: c_int) callconv(.c) ?*anyopaque,
    f_slice: ?*const fn (p_self: *gee.List, p_start: c_int, p_stop: c_int) callconv(.c) ?*gee.List,
    f_first: ?*const fn (p_self: *gee.List) callconv(.c) ?*anyopaque,
    f_last: ?*const fn (p_self: *gee.List) callconv(.c) ?*anyopaque,
    f_insert_all: ?*const fn (p_self: *gee.List, p_index: c_int, p_collection: *gee.Collection) callconv(.c) void,
    f_sort: ?*const fn (p_self: *gee.List, p_compare_func: ?glib.CompareDataFunc, p_compare_func_target: ?*anyopaque, p_compare_func_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) void,
    f_get_read_only_view: ?*const fn (p_self: *gee.List) callconv(.c) *gee.List,

    pub fn as(p_instance: *ListIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ListIteratorIface = extern struct {
    pub const Instance = gee.ListIterator;

    f_parent_iface: gobject.TypeInterface,
    f_set: ?*const fn (p_self: *gee.ListIterator, p_item: ?*anyopaque) callconv(.c) void,
    f_add: ?*const fn (p_self: *gee.ListIterator, p_item: ?*anyopaque) callconv(.c) void,
    f_index: ?*const fn (p_self: *gee.ListIterator) callconv(.c) c_int,

    pub fn as(p_instance: *ListIteratorIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MapIface = extern struct {
    pub const Instance = gee.Map;

    f_parent_iface: gobject.TypeInterface,
    f_has_key: ?*const fn (p_self: *gee.Map, p_key: ?*anyopaque) callconv(.c) c_int,
    f_has: ?*const fn (p_self: *gee.Map, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int,
    f_get: ?*const fn (p_self: *gee.Map, p_key: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_set: ?*const fn (p_self: *gee.Map, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) void,
    f_unset: ?*const fn (p_self: *gee.Map, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int,
    f_clear: ?*const fn (p_self: *gee.Map) callconv(.c) void,
    f_map_iterator: ?*const fn (p_self: *gee.Map) callconv(.c) *gee.MapIterator,
    f_set_all: ?*const fn (p_self: *gee.Map, p_map: *gee.Map) callconv(.c) void,
    f_unset_all: ?*const fn (p_self: *gee.Map, p_map: *gee.Map) callconv(.c) c_int,
    f_has_all: ?*const fn (p_self: *gee.Map, p_map: *gee.Map) callconv(.c) c_int,
    f_get_size: ?*const fn (p_self: *gee.Map) callconv(.c) c_int,
    f_get_is_empty: ?*const fn (p_self: *gee.Map) callconv(.c) c_int,
    f_get_read_only: ?*const fn (p_self: *gee.Map) callconv(.c) c_int,
    f_get_keys: ?*const fn (p_self: *gee.Map) callconv(.c) *gee.Set,
    f_get_values: ?*const fn (p_self: *gee.Map) callconv(.c) *gee.Collection,
    f_get_entries: ?*const fn (p_self: *gee.Map) callconv(.c) *gee.Set,
    f_get_read_only_view: ?*const fn (p_self: *gee.Map) callconv(.c) *gee.Map,

    pub fn as(p_instance: *MapIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MapEntryClass = extern struct {
    pub const Instance = gee.MapEntry;

    f_parent_class: gobject.ObjectClass,

    pub fn as(p_instance: *MapEntryClass, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MapEntryPrivate = *opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MapIteratorIface = extern struct {
    pub const Instance = gee.MapIterator;

    f_parent_iface: gobject.TypeInterface,
    f_next: ?*const fn (p_self: *gee.MapIterator) callconv(.c) c_int,
    f_has_next: ?*const fn (p_self: *gee.MapIterator) callconv(.c) c_int,
    f_get_key: ?*const fn (p_self: *gee.MapIterator) callconv(.c) ?*anyopaque,
    f_get_value: ?*const fn (p_self: *gee.MapIterator) callconv(.c) ?*anyopaque,
    f_set_value: ?*const fn (p_self: *gee.MapIterator, p_value: ?*anyopaque) callconv(.c) void,
    f_unset: ?*const fn (p_self: *gee.MapIterator) callconv(.c) void,
    f_fold: ?*const fn (p_self: *gee.MapIterator, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldMapFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_foreach: ?*const fn (p_self: *gee.MapIterator, p_f: gee.ForallMapFunc, p_f_target: ?*anyopaque) callconv(.c) c_int,
    f_get_valid: ?*const fn (p_self: *gee.MapIterator) callconv(.c) c_int,
    f_get_mutable: ?*const fn (p_self: *gee.MapIterator) callconv(.c) c_int,
    f_get_read_only: ?*const fn (p_self: *gee.MapIterator) callconv(.c) c_int,

    pub fn as(p_instance: *MapIteratorIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MultiMapIface = extern struct {
    pub const Instance = gee.MultiMap;

    f_parent_iface: gobject.TypeInterface,
    f_get_keys: ?*const fn (p_self: *gee.MultiMap) callconv(.c) *gee.Set,
    f_get_all_keys: ?*const fn (p_self: *gee.MultiMap) callconv(.c) *gee.MultiSet,
    f_get_values: ?*const fn (p_self: *gee.MultiMap) callconv(.c) *gee.Collection,
    f_contains: ?*const fn (p_self: *gee.MultiMap, p_key: ?*anyopaque) callconv(.c) c_int,
    f_get: ?*const fn (p_self: *gee.MultiMap, p_key: ?*anyopaque) callconv(.c) *gee.Collection,
    f_set: ?*const fn (p_self: *gee.MultiMap, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) void,
    f_remove: ?*const fn (p_self: *gee.MultiMap, p_key: ?*anyopaque, p_value: ?*anyopaque) callconv(.c) c_int,
    f_remove_all: ?*const fn (p_self: *gee.MultiMap, p_key: ?*anyopaque) callconv(.c) c_int,
    f_clear: ?*const fn (p_self: *gee.MultiMap) callconv(.c) void,
    f_map_iterator: ?*const fn (p_self: *gee.MultiMap) callconv(.c) *gee.MapIterator,
    f_get_size: ?*const fn (p_self: *gee.MultiMap) callconv(.c) c_int,
    f_get_read_only: ?*const fn (p_self: *gee.MultiMap) callconv(.c) c_int,
    f_get_read_only_view: ?*const fn (p_self: *gee.MultiMap) callconv(.c) *gee.MultiMap,

    pub fn as(p_instance: *MultiMapIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const MultiSetIface = extern struct {
    pub const Instance = gee.MultiSet;

    f_parent_iface: gobject.TypeInterface,
    f_count: ?*const fn (p_self: *gee.MultiSet, p_item: ?*anyopaque) callconv(.c) c_int,
    f_get_read_only_view: ?*const fn (p_self: *gee.MultiSet) callconv(.c) *gee.MultiSet,

    pub fn as(p_instance: *MultiSetIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const QueueIface = extern struct {
    pub const Instance = gee.Queue;

    f_parent_iface: gobject.TypeInterface,
    f_offer: ?*const fn (p_self: *gee.Queue, p_element: ?*anyopaque) callconv(.c) c_int,
    f_peek: ?*const fn (p_self: *gee.Queue) callconv(.c) ?*anyopaque,
    f_poll: ?*const fn (p_self: *gee.Queue) callconv(.c) ?*anyopaque,
    f_drain: ?*const fn (p_self: *gee.Queue, p_recipient: *gee.Collection, p_amount: c_int) callconv(.c) c_int,
    f_get_capacity: ?*const fn (p_self: *gee.Queue) callconv(.c) c_int,
    f_get_remaining_capacity: ?*const fn (p_self: *gee.Queue) callconv(.c) c_int,
    f_get_is_full: ?*const fn (p_self: *gee.Queue) callconv(.c) c_int,

    pub fn as(p_instance: *QueueIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const SetIface = extern struct {
    pub const Instance = gee.Set;

    f_parent_iface: gobject.TypeInterface,
    f_get_read_only_view: ?*const fn (p_self: *gee.Set) callconv(.c) *gee.Set,

    pub fn as(p_instance: *SetIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const SortedMapIface = extern struct {
    pub const Instance = gee.SortedMap;

    f_parent_iface: gobject.TypeInterface,
    f_head_map: ?*const fn (p_self: *gee.SortedMap, p_before: ?*anyopaque) callconv(.c) *gee.SortedMap,
    f_tail_map: ?*const fn (p_self: *gee.SortedMap, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap,
    f_sub_map: ?*const fn (p_self: *gee.SortedMap, p_before: ?*anyopaque, p_after: ?*anyopaque) callconv(.c) *gee.SortedMap,
    f_get_ascending_keys: ?*const fn (p_self: *gee.SortedMap) callconv(.c) *gee.SortedSet,
    f_get_ascending_entries: ?*const fn (p_self: *gee.SortedMap) callconv(.c) *gee.SortedSet,
    f_get_read_only_view: ?*const fn (p_self: *gee.SortedMap) callconv(.c) *gee.SortedMap,

    pub fn as(p_instance: *SortedMapIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const SortedSetIface = extern struct {
    pub const Instance = gee.SortedSet;

    f_parent_iface: gobject.TypeInterface,
    f_first: ?*const fn (p_self: *gee.SortedSet) callconv(.c) ?*anyopaque,
    f_last: ?*const fn (p_self: *gee.SortedSet) callconv(.c) ?*anyopaque,
    f_iterator_at: ?*const fn (p_self: *gee.SortedSet, p_element: ?*anyopaque) callconv(.c) ?*gee.Iterator,
    f_lower: ?*const fn (p_self: *gee.SortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_higher: ?*const fn (p_self: *gee.SortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_floor: ?*const fn (p_self: *gee.SortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_ceil: ?*const fn (p_self: *gee.SortedSet, p_element: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_head_set: ?*const fn (p_self: *gee.SortedSet, p_before: ?*anyopaque) callconv(.c) *gee.SortedSet,
    f_tail_set: ?*const fn (p_self: *gee.SortedSet, p_after: ?*anyopaque) callconv(.c) *gee.SortedSet,
    f_sub_set: ?*const fn (p_self: *gee.SortedSet, p_from: ?*anyopaque, p_to: ?*anyopaque) callconv(.c) *gee.SortedSet,
    f_get_read_only_view: ?*const fn (p_self: *gee.SortedSet) callconv(.c) *gee.SortedSet,

    pub fn as(p_instance: *SortedSetIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TraversableIface = extern struct {
    pub const Instance = gee.Traversable;

    f_parent_iface: gobject.TypeInterface,
    f_foreach: ?*const fn (p_self: *gee.Traversable, p_f: gee.ForallFunc, p_f_target: ?*anyopaque) callconv(.c) c_int,
    f_stream: ?*const fn (p_self: *gee.Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.StreamFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator,
    f_fold: ?*const fn (p_self: *gee.Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) callconv(.c) ?*anyopaque,
    f_map: ?*const fn (p_self: *gee.Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.MapFunc, p_f_target: ?*anyopaque) callconv(.c) *gee.Iterator,
    f_scan: ?*const fn (p_self: *gee.Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FoldFunc, p_f_target: ?*anyopaque, p_seed: ?*anyopaque) callconv(.c) *gee.Iterator,
    f_filter: ?*const fn (p_self: *gee.Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator,
    f_chop: ?*const fn (p_self: *gee.Traversable, p_offset: c_int, p_length: c_int) callconv(.c) *gee.Iterator,
    f_flat_map: ?*const fn (p_self: *gee.Traversable, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_f: gee.FlatMapFunc, p_f_target: ?*anyopaque, p_f_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator,
    f_tee: ?*const fn (p_self: *gee.Traversable, p_forks: c_uint, p_result_length1: *c_int) callconv(.c) [*]*gee.Iterator,
    f_first_match: ?*const fn (p_self: *gee.Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) ?*anyopaque,
    f_any_match: ?*const fn (p_self: *gee.Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) c_int,
    f_all_match: ?*const fn (p_self: *gee.Traversable, p_pred: gee.Predicate, p_pred_target: ?*anyopaque, p_pred_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) c_int,
    f_max: ?*const fn (p_self: *gee.Traversable, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) ?*anyopaque,
    f_min: ?*const fn (p_self: *gee.Traversable, p_compare: glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) ?*anyopaque,
    f_order_by: ?*const fn (p_self: *gee.Traversable, p_compare: ?glib.CompareDataFunc, p_compare_target: ?*anyopaque, p_compare_target_destroy_notify: ?glib.DestroyNotify) callconv(.c) *gee.Iterator,
    f_get_element_type: ?*const fn (p_self: *gee.Traversable) callconv(.c) usize,

    pub fn as(p_instance: *TraversableIface, comptime P_T: type) *P_T {
        return gobject.ext.as(P_T, p_instance);
    }

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HazardPointerNode = opaque {
    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const FutureError = enum(c_int) {
    abandon_promise = 0,
    exception = 1,
    _,

    extern fn gee_future_error_get_type() usize;
    pub const getGObjectType = gee_future_error_get_type;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const ConcurrentSetRangeType = enum(c_int) {
    head = 0,
    tail = 1,
    bounded = 2,
    empty = 3,
    _,

    extern fn gee_concurrent_set_range_type_get_type() usize;
    pub const getGObjectType = gee_concurrent_set_range_type_get_type;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HazardPointerPolicy = enum(c_int) {
    default = 0,
    thread_exit = 1,
    try_free = 2,
    free = 3,
    try_release = 4,
    release = 5,
    _,

    extern fn gee_hazard_pointer_policy_get_type() usize;
    pub const getGObjectType = gee_hazard_pointer_policy_get_type;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const HazardPointerReleasePolicy = enum(c_int) {
    helper_thread = 0,
    main_loop = 1,
    _,

    extern fn gee_hazard_pointer_release_policy_get_type() usize;
    pub const getGObjectType = gee_hazard_pointer_release_policy_get_type;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

pub const TraversableStream = enum(c_int) {
    yield = 0,
    @"continue" = 1,
    end = 2,
    wait = 3,
    _,

    extern fn gee_traversable_stream_get_type() usize;
    pub const getGObjectType = gee_traversable_stream_get_type;

    test {
        @setEvalBranchQuota(100_000);
        std.testing.refAllDecls(@This());
    }
};

extern fn gee_functions_get_equal_func_for(p_t: usize, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) gee.EqualDataFunc;
pub const functionsGetEqualFuncFor = gee_functions_get_equal_func_for;

extern fn gee_functions_get_hash_func_for(p_t: usize, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) gee.HashDataFunc;
pub const functionsGetHashFuncFor = gee_functions_get_hash_func_for;

extern fn gee_functions_get_compare_func_for(p_t: usize, p_result_target: ?*anyopaque, p_result_target_destroy_notify: *glib.DestroyNotify) glib.CompareDataFunc;
pub const functionsGetCompareFuncFor = gee_functions_get_compare_func_for;

extern fn gee_hazard_pointer_policy_is_concrete(p_self: gee.HazardPointerPolicy) c_int;
pub const hazardPointerPolicyIsConcrete = gee_hazard_pointer_policy_is_concrete;

extern fn gee_hazard_pointer_policy_is_blocking(p_self: gee.HazardPointerPolicy) c_int;
pub const hazardPointerPolicyIsBlocking = gee_hazard_pointer_policy_is_blocking;

extern fn gee_hazard_pointer_policy_is_safe(p_self: gee.HazardPointerPolicy) c_int;
pub const hazardPointerPolicyIsSafe = gee_hazard_pointer_policy_is_safe;

extern fn gee_hazard_pointer_policy_to_concrete(p_self: gee.HazardPointerPolicy) gee.HazardPointerPolicy;
pub const hazardPointerPolicyToConcrete = gee_hazard_pointer_policy_to_concrete;

extern fn gee_task(p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_task: gee.Task, p_task_target: ?*anyopaque, p_error: ?*?*glib.Error) ?*gee.Future;
pub const task = gee_task;

extern fn gee_async_task(p__callback_: ?gio.AsyncReadyCallback, p__callback__target: ?*anyopaque) void;
pub const asyncTask = gee_async_task;

extern fn gee_async_task_finish(p__res_: *gio.AsyncResult, p_error: ?*?*glib.Error) void;
pub const asyncTaskFinish = gee_async_task_finish;

pub const HashDataFunc = *const fn (p_t_type: usize, p_t_dup_func: gobject.BoxedCopyFunc, p_t_destroy_func: glib.DestroyNotify, p_v: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) c_uint;

pub const EqualDataFunc = *const fn (p_t_type: usize, p_t_dup_func: gobject.BoxedCopyFunc, p_t_destroy_func: glib.DestroyNotify, p_a: ?*anyopaque, p_b: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) c_int;

pub const LazyFunc = *const fn (p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

pub const FoldMapFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify, p_k: ?*anyopaque, p_v: ?*anyopaque, p_a: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

pub const ForallMapFunc = *const fn (p_k_type: usize, p_k_dup_func: gobject.BoxedCopyFunc, p_k_destroy_func: glib.DestroyNotify, p_v_type: usize, p_v_dup_func: gobject.BoxedCopyFunc, p_v_destroy_func: glib.DestroyNotify, p_k: ?*anyopaque, p_v: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) c_int;

pub const Task = *const fn (p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

pub const FoldFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_g: ?*anyopaque, p_a: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

pub const ForallFunc = *const fn (p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_g: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) c_int;

pub const UnfoldFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_user_data: ?*anyopaque) callconv(.c) ?*gee.Lazy;

pub const StreamFunc = *const fn (p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_state: gee.TraversableStream, p_g: ?*gee.Lazy, p_lazy: ?**gee.Lazy, p_user_data: ?*anyopaque) callconv(.c) gee.TraversableStream;

pub const MapFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_g: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) ?*anyopaque;

pub const Predicate = *const fn (p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_g: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) c_int;

pub const FlatMapFunc = *const fn (p_a_type: usize, p_a_dup_func: gobject.BoxedCopyFunc, p_a_destroy_func: glib.DestroyNotify, p_g_type: usize, p_g_dup_func: gobject.BoxedCopyFunc, p_g_destroy_func: glib.DestroyNotify, p_g: ?*anyopaque, p_user_data: ?*anyopaque) callconv(.c) *gee.Iterator;

test {
    @setEvalBranchQuota(100_000);
    std.testing.refAllDecls(@This());
    std.testing.refAllDecls(ext);
}
