# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.5.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

package libdnf5::rpm;
use base qw(Exporter);
use base qw(DynaLoader);
require libdnf5::common;
require libdnf5::exception;
require libdnf5::conf;
require libdnf5::logger;
require libdnf5::repo;
require libdnf5::transaction;
package libdnf5::rpmc;
bootstrap libdnf5::rpm;
package libdnf5::rpm;
@EXPORT = qw();

# ---------- BASE METHODS -------------

package libdnf5::rpm;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package libdnf5::rpm;

*get_supported_arches = *libdnf5::rpmc::get_supported_arches;
*get_base_arch = *libdnf5::rpmc::get_base_arch;
*__lshift__ = *libdnf5::rpmc::__lshift__;
*rpmvercmp = *libdnf5::rpmc::rpmvercmp;
*cmp_nevra = *libdnf5::rpmc::cmp_nevra;
*to_full_nevra_string = *libdnf5::rpmc::to_full_nevra_string;
*to_nevra_string = *libdnf5::rpmc::to_nevra_string;

############# Class : libdnf5::rpm::Checksum ##############

package libdnf5::rpm::Checksum;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_Checksum($self);
        delete $OWNER{$self};
    }
}

sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_Checksum(@_);
    bless $self, $pkg if defined($self);
}

*Type_UNKNOWN = *libdnf5::rpmc::Checksum_Type_UNKNOWN;
*Type_MD5 = *libdnf5::rpmc::Checksum_Type_MD5;
*Type_SHA1 = *libdnf5::rpmc::Checksum_Type_SHA1;
*Type_SHA224 = *libdnf5::rpmc::Checksum_Type_SHA224;
*Type_SHA256 = *libdnf5::rpmc::Checksum_Type_SHA256;
*Type_SHA384 = *libdnf5::rpmc::Checksum_Type_SHA384;
*Type_SHA512 = *libdnf5::rpmc::Checksum_Type_SHA512;
*get_type = *libdnf5::rpmc::Checksum_get_type;
*get_type_str = *libdnf5::rpmc::Checksum_get_type_str;
*get_checksum = *libdnf5::rpmc::Checksum_get_checksum;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::Nevra ##############

package libdnf5::rpm::Nevra;
use overload
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*Form_NEVRA = *libdnf5::rpmc::Nevra_Form_NEVRA;
*Form_NEVR = *libdnf5::rpmc::Nevra_Form_NEVR;
*Form_NEV = *libdnf5::rpmc::Nevra_Form_NEV;
*Form_NA = *libdnf5::rpmc::Nevra_Form_NA;
*Form_NAME = *libdnf5::rpmc::Nevra_Form_NAME;
*get_default_pkg_spec_forms = *libdnf5::rpmc::Nevra_get_default_pkg_spec_forms;
*parse = *libdnf5::rpmc::Nevra_parse;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_Nevra($self);
        delete $OWNER{$self};
    }
}

sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_Nevra(@_);
    bless $self, $pkg if defined($self);
}

*__eq__ = *libdnf5::rpmc::Nevra___eq__;
*clear = *libdnf5::rpmc::Nevra_clear;
*get_name = *libdnf5::rpmc::Nevra_get_name;
*get_epoch = *libdnf5::rpmc::Nevra_get_epoch;
*get_version = *libdnf5::rpmc::Nevra_get_version;
*get_release = *libdnf5::rpmc::Nevra_get_release;
*get_arch = *libdnf5::rpmc::Nevra_get_arch;
*set_name = *libdnf5::rpmc::Nevra_set_name;
*set_epoch = *libdnf5::rpmc::Nevra_set_epoch;
*set_version = *libdnf5::rpmc::Nevra_set_version;
*set_release = *libdnf5::rpmc::Nevra_set_release;
*set_arch = *libdnf5::rpmc::Nevra_set_arch;
*has_just_name = *libdnf5::rpmc::Nevra_has_just_name;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorNevra ##############

package libdnf5::rpm::VectorNevra;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorNevra(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorNevra_size;
*empty = *libdnf5::rpmc::VectorNevra_empty;
*clear = *libdnf5::rpmc::VectorNevra_clear;
*push = *libdnf5::rpmc::VectorNevra_push;
*pop = *libdnf5::rpmc::VectorNevra_pop;
*get = *libdnf5::rpmc::VectorNevra_get;
*set = *libdnf5::rpmc::VectorNevra_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorNevra($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorNevraForm ##############

package libdnf5::rpm::VectorNevraForm;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorNevraForm(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorNevraForm_size;
*empty = *libdnf5::rpmc::VectorNevraForm_empty;
*clear = *libdnf5::rpmc::VectorNevraForm_clear;
*push = *libdnf5::rpmc::VectorNevraForm_push;
*pop = *libdnf5::rpmc::VectorNevraForm_pop;
*get = *libdnf5::rpmc::VectorNevraForm_get;
*set = *libdnf5::rpmc::VectorNevraForm_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorNevraForm($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PairBoolNevra ##############

package libdnf5::rpm::PairBoolNevra;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PairBoolNevra(@_);
    bless $self, $pkg if defined($self);
}

*swig_first_get = *libdnf5::rpmc::PairBoolNevra_first_get;
*swig_first_set = *libdnf5::rpmc::PairBoolNevra_first_set;
*swig_second_get = *libdnf5::rpmc::PairBoolNevra_second_get;
*swig_second_set = *libdnf5::rpmc::PairBoolNevra_second_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PairBoolNevra($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VersionlockCondition ##############

package libdnf5::rpm::VersionlockCondition;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*Keys_EPOCH = *libdnf5::rpmc::VersionlockCondition_Keys_EPOCH;
*Keys_EVR = *libdnf5::rpmc::VersionlockCondition_Keys_EVR;
*Keys_ARCH = *libdnf5::rpmc::VersionlockCondition_Keys_ARCH;
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VersionlockCondition(@_);
    bless $self, $pkg if defined($self);
}

*is_valid = *libdnf5::rpmc::VersionlockCondition_is_valid;
*get_key = *libdnf5::rpmc::VersionlockCondition_get_key;
*get_comparator = *libdnf5::rpmc::VersionlockCondition_get_comparator;
*get_value = *libdnf5::rpmc::VersionlockCondition_get_value;
*get_key_str = *libdnf5::rpmc::VersionlockCondition_get_key_str;
*get_comparator_str = *libdnf5::rpmc::VersionlockCondition_get_comparator_str;
*get_errors = *libdnf5::rpmc::VersionlockCondition_get_errors;
*to_string = *libdnf5::rpmc::VersionlockCondition_to_string;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VersionlockCondition($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VersionlockPackage ##############

package libdnf5::rpm::VersionlockPackage;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VersionlockPackage(@_);
    bless $self, $pkg if defined($self);
}

*is_valid = *libdnf5::rpmc::VersionlockPackage_is_valid;
*get_name = *libdnf5::rpmc::VersionlockPackage_get_name;
*get_comment = *libdnf5::rpmc::VersionlockPackage_get_comment;
*set_comment = *libdnf5::rpmc::VersionlockPackage_set_comment;
*get_conditions = *libdnf5::rpmc::VersionlockPackage_get_conditions;
*add_condition = *libdnf5::rpmc::VersionlockPackage_add_condition;
*get_errors = *libdnf5::rpmc::VersionlockPackage_get_errors;
*to_string = *libdnf5::rpmc::VersionlockPackage_to_string;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VersionlockPackage($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VersionlockConfig ##############

package libdnf5::rpm::VersionlockConfig;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*get_packages = *libdnf5::rpmc::VersionlockConfig_get_packages;
*save = *libdnf5::rpmc::VersionlockConfig_save;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VersionlockConfig($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorVersionlockCondition ##############

package libdnf5::rpm::VectorVersionlockCondition;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorVersionlockCondition(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorVersionlockCondition_size;
*empty = *libdnf5::rpmc::VectorVersionlockCondition_empty;
*clear = *libdnf5::rpmc::VectorVersionlockCondition_clear;
*push = *libdnf5::rpmc::VectorVersionlockCondition_push;
*pop = *libdnf5::rpmc::VectorVersionlockCondition_pop;
*get = *libdnf5::rpmc::VectorVersionlockCondition_get;
*set = *libdnf5::rpmc::VectorVersionlockCondition_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorVersionlockCondition($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorVersionlockPackage ##############

package libdnf5::rpm::VectorVersionlockPackage;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorVersionlockPackage(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorVersionlockPackage_size;
*empty = *libdnf5::rpmc::VectorVersionlockPackage_empty;
*clear = *libdnf5::rpmc::VectorVersionlockPackage_clear;
*push = *libdnf5::rpmc::VectorVersionlockPackage_push;
*pop = *libdnf5::rpmc::VectorVersionlockPackage_pop;
*get = *libdnf5::rpmc::VectorVersionlockPackage_get;
*set = *libdnf5::rpmc::VectorVersionlockPackage_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorVersionlockPackage($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PackageSack ##############

package libdnf5::rpm::PackageSack;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PackageSack(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PackageSack($self);
        delete $OWNER{$self};
    }
}

*get_weak_ptr = *libdnf5::rpmc::PackageSack_get_weak_ptr;
*get_base = *libdnf5::rpmc::PackageSack_get_base;
*get_nsolvables = *libdnf5::rpmc::PackageSack_get_nsolvables;
*load_config_excludes_includes = *libdnf5::rpmc::PackageSack_load_config_excludes_includes;
*get_user_excludes = *libdnf5::rpmc::PackageSack_get_user_excludes;
*add_user_excludes = *libdnf5::rpmc::PackageSack_add_user_excludes;
*remove_user_excludes = *libdnf5::rpmc::PackageSack_remove_user_excludes;
*set_user_excludes = *libdnf5::rpmc::PackageSack_set_user_excludes;
*clear_user_excludes = *libdnf5::rpmc::PackageSack_clear_user_excludes;
*get_user_includes = *libdnf5::rpmc::PackageSack_get_user_includes;
*add_user_includes = *libdnf5::rpmc::PackageSack_add_user_includes;
*remove_user_includes = *libdnf5::rpmc::PackageSack_remove_user_includes;
*set_user_includes = *libdnf5::rpmc::PackageSack_set_user_includes;
*clear_user_includes = *libdnf5::rpmc::PackageSack_clear_user_includes;
*get_versionlock_config = *libdnf5::rpmc::PackageSack_get_versionlock_config;
*get_versionlock_excludes = *libdnf5::rpmc::PackageSack_get_versionlock_excludes;
*add_versionlock_excludes = *libdnf5::rpmc::PackageSack_add_versionlock_excludes;
*remove_versionlock_excludes = *libdnf5::rpmc::PackageSack_remove_versionlock_excludes;
*set_versionlock_excludes = *libdnf5::rpmc::PackageSack_set_versionlock_excludes;
*clear_versionlock_excludes = *libdnf5::rpmc::PackageSack_clear_versionlock_excludes;
*get_running_kernel = *libdnf5::rpmc::PackageSack_get_running_kernel;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PackageSackWeakPtr ##############

package libdnf5::rpm::PackageSackWeakPtr;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    ">=" => sub { $_[0]->__ge__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "<=" => sub { $_[0]->__le__($_[1])},
    ">" => sub { $_[0]->__gt__($_[1])},
    "<" => sub { $_[0]->__lt__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PackageSackWeakPtr(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PackageSackWeakPtr($self);
        delete $OWNER{$self};
    }
}

*__deref__ = *libdnf5::rpmc::PackageSackWeakPtr___deref__;
*get = *libdnf5::rpmc::PackageSackWeakPtr_get;
*is_valid = *libdnf5::rpmc::PackageSackWeakPtr_is_valid;
*has_same_guard = *libdnf5::rpmc::PackageSackWeakPtr_has_same_guard;
*__ref__ = *libdnf5::rpmc::PackageSackWeakPtr___ref__;
*__eq__ = *libdnf5::rpmc::PackageSackWeakPtr___eq__;
*__ne__ = *libdnf5::rpmc::PackageSackWeakPtr___ne__;
*__lt__ = *libdnf5::rpmc::PackageSackWeakPtr___lt__;
*__gt__ = *libdnf5::rpmc::PackageSackWeakPtr___gt__;
*__le__ = *libdnf5::rpmc::PackageSackWeakPtr___le__;
*__ge__ = *libdnf5::rpmc::PackageSackWeakPtr___ge__;
*get_weak_ptr = *libdnf5::rpmc::PackageSackWeakPtr_get_weak_ptr;
*get_base = *libdnf5::rpmc::PackageSackWeakPtr_get_base;
*get_nsolvables = *libdnf5::rpmc::PackageSackWeakPtr_get_nsolvables;
*load_config_excludes_includes = *libdnf5::rpmc::PackageSackWeakPtr_load_config_excludes_includes;
*get_user_excludes = *libdnf5::rpmc::PackageSackWeakPtr_get_user_excludes;
*add_user_excludes = *libdnf5::rpmc::PackageSackWeakPtr_add_user_excludes;
*remove_user_excludes = *libdnf5::rpmc::PackageSackWeakPtr_remove_user_excludes;
*set_user_excludes = *libdnf5::rpmc::PackageSackWeakPtr_set_user_excludes;
*clear_user_excludes = *libdnf5::rpmc::PackageSackWeakPtr_clear_user_excludes;
*get_user_includes = *libdnf5::rpmc::PackageSackWeakPtr_get_user_includes;
*add_user_includes = *libdnf5::rpmc::PackageSackWeakPtr_add_user_includes;
*remove_user_includes = *libdnf5::rpmc::PackageSackWeakPtr_remove_user_includes;
*set_user_includes = *libdnf5::rpmc::PackageSackWeakPtr_set_user_includes;
*clear_user_includes = *libdnf5::rpmc::PackageSackWeakPtr_clear_user_includes;
*get_versionlock_config = *libdnf5::rpmc::PackageSackWeakPtr_get_versionlock_config;
*get_versionlock_excludes = *libdnf5::rpmc::PackageSackWeakPtr_get_versionlock_excludes;
*add_versionlock_excludes = *libdnf5::rpmc::PackageSackWeakPtr_add_versionlock_excludes;
*remove_versionlock_excludes = *libdnf5::rpmc::PackageSackWeakPtr_remove_versionlock_excludes;
*set_versionlock_excludes = *libdnf5::rpmc::PackageSackWeakPtr_set_versionlock_excludes;
*clear_versionlock_excludes = *libdnf5::rpmc::PackageSackWeakPtr_clear_versionlock_excludes;
*get_running_kernel = *libdnf5::rpmc::PackageSackWeakPtr_get_running_kernel;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::ReldepId ##############

package libdnf5::rpm::ReldepId;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_ReldepId(@_);
    bless $self, $pkg if defined($self);
}

*__eq__ = *libdnf5::rpmc::ReldepId___eq__;
*__ne__ = *libdnf5::rpmc::ReldepId___ne__;
*swig_id_get = *libdnf5::rpmc::ReldepId_id_get;
*swig_id_set = *libdnf5::rpmc::ReldepId_id_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_ReldepId($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::Reldep ##############

package libdnf5::rpm::Reldep;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*CmpType_NONE = *libdnf5::rpmc::Reldep_CmpType_NONE;
*CmpType_GT = *libdnf5::rpmc::Reldep_CmpType_GT;
*CmpType_EQ = *libdnf5::rpmc::Reldep_CmpType_EQ;
*CmpType_GTE = *libdnf5::rpmc::Reldep_CmpType_GTE;
*CmpType_LT = *libdnf5::rpmc::Reldep_CmpType_LT;
*CmpType_LTE = *libdnf5::rpmc::Reldep_CmpType_LTE;
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_Reldep(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_Reldep($self);
        delete $OWNER{$self};
    }
}

*__eq__ = *libdnf5::rpmc::Reldep___eq__;
*__ne__ = *libdnf5::rpmc::Reldep___ne__;
*get_name = *libdnf5::rpmc::Reldep_get_name;
*get_relation = *libdnf5::rpmc::Reldep_get_relation;
*get_version = *libdnf5::rpmc::Reldep_get_version;
*to_string = *libdnf5::rpmc::Reldep_to_string;
*to_string_description = *libdnf5::rpmc::Reldep_to_string_description;
*get_id = *libdnf5::rpmc::Reldep_get_id;
*get_base = *libdnf5::rpmc::Reldep_get_base;
*is_rich_dependency = *libdnf5::rpmc::Reldep_is_rich_dependency;
*get_hash = *libdnf5::rpmc::Reldep_get_hash;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::ReldepListIterator ##############

package libdnf5::rpm::ReldepListIterator;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "++" => sub { $_[0]->__plusplus__()},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_ReldepListIterator(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_ReldepListIterator($self);
        delete $OWNER{$self};
    }
}

*value = *libdnf5::rpmc::ReldepListIterator_value;
*next = *libdnf5::rpmc::ReldepListIterator_next;
*__plusplus__ = *libdnf5::rpmc::ReldepListIterator___plusplus__;
*__eq__ = *libdnf5::rpmc::ReldepListIterator___eq__;
*__ne__ = *libdnf5::rpmc::ReldepListIterator___ne__;
*begin = *libdnf5::rpmc::ReldepListIterator_begin;
*end = *libdnf5::rpmc::ReldepListIterator_end;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::ReldepList ##############

package libdnf5::rpm::ReldepList;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_ReldepList(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_ReldepList($self);
        delete $OWNER{$self};
    }
}

*begin = *libdnf5::rpmc::ReldepList_begin;
*end = *libdnf5::rpmc::ReldepList_end;
*__eq__ = *libdnf5::rpmc::ReldepList___eq__;
*__ne__ = *libdnf5::rpmc::ReldepList___ne__;
*add = *libdnf5::rpmc::ReldepList_add;
*add_reldep_with_glob = *libdnf5::rpmc::ReldepList_add_reldep_with_glob;
*add_reldep = *libdnf5::rpmc::ReldepList_add_reldep;
*append = *libdnf5::rpmc::ReldepList_append;
*get = *libdnf5::rpmc::ReldepList_get;
*get_id = *libdnf5::rpmc::ReldepList_get_id;
*size = *libdnf5::rpmc::ReldepList_size;
*empty = *libdnf5::rpmc::ReldepList_empty;
*clear = *libdnf5::rpmc::ReldepList_clear;
*get_base = *libdnf5::rpmc::ReldepList_get_base;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PackageId ##############

package libdnf5::rpm::PackageId;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "<" => sub { $_[0]->__lt__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PackageId(@_);
    bless $self, $pkg if defined($self);
}

*__eq__ = *libdnf5::rpmc::PackageId___eq__;
*__ne__ = *libdnf5::rpmc::PackageId___ne__;
*__lt__ = *libdnf5::rpmc::PackageId___lt__;
*swig_id_get = *libdnf5::rpmc::PackageId_id_get;
*swig_id_set = *libdnf5::rpmc::PackageId_id_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PackageId($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::Changelog ##############

package libdnf5::rpm::Changelog;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_Changelog($self);
        delete $OWNER{$self};
    }
}

sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_Changelog(@_);
    bless $self, $pkg if defined($self);
}

*get_timestamp = *libdnf5::rpmc::Changelog_get_timestamp;
*get_author = *libdnf5::rpmc::Changelog_get_author;
*get_text = *libdnf5::rpmc::Changelog_get_text;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::Package ##############

package libdnf5::rpm::Package;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "==" => sub { $_[0]->__eq__($_[1])},
    "<" => sub { $_[0]->__lt__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_Package($self);
        delete $OWNER{$self};
    }
}

sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_Package(@_);
    bless $self, $pkg if defined($self);
}

*__eq__ = *libdnf5::rpmc::Package___eq__;
*__ne__ = *libdnf5::rpmc::Package___ne__;
*__lt__ = *libdnf5::rpmc::Package___lt__;
*get_id = *libdnf5::rpmc::Package_get_id;
*get_name = *libdnf5::rpmc::Package_get_name;
*get_epoch = *libdnf5::rpmc::Package_get_epoch;
*get_version = *libdnf5::rpmc::Package_get_version;
*get_release = *libdnf5::rpmc::Package_get_release;
*get_arch = *libdnf5::rpmc::Package_get_arch;
*get_evr = *libdnf5::rpmc::Package_get_evr;
*get_nevra = *libdnf5::rpmc::Package_get_nevra;
*get_full_nevra = *libdnf5::rpmc::Package_get_full_nevra;
*get_na = *libdnf5::rpmc::Package_get_na;
*get_group = *libdnf5::rpmc::Package_get_group;
*get_download_size = *libdnf5::rpmc::Package_get_download_size;
*get_install_size = *libdnf5::rpmc::Package_get_install_size;
*get_license = *libdnf5::rpmc::Package_get_license;
*get_source_name = *libdnf5::rpmc::Package_get_source_name;
*get_debugsource_name = *libdnf5::rpmc::Package_get_debugsource_name;
*get_debuginfo_name_of_source = *libdnf5::rpmc::Package_get_debuginfo_name_of_source;
*get_debuginfo_name = *libdnf5::rpmc::Package_get_debuginfo_name;
*get_sourcerpm = *libdnf5::rpmc::Package_get_sourcerpm;
*get_build_time = *libdnf5::rpmc::Package_get_build_time;
*get_packager = *libdnf5::rpmc::Package_get_packager;
*get_vendor = *libdnf5::rpmc::Package_get_vendor;
*get_url = *libdnf5::rpmc::Package_get_url;
*get_summary = *libdnf5::rpmc::Package_get_summary;
*get_description = *libdnf5::rpmc::Package_get_description;
*get_provides = *libdnf5::rpmc::Package_get_provides;
*get_requires = *libdnf5::rpmc::Package_get_requires;
*get_requires_pre = *libdnf5::rpmc::Package_get_requires_pre;
*get_conflicts = *libdnf5::rpmc::Package_get_conflicts;
*get_obsoletes = *libdnf5::rpmc::Package_get_obsoletes;
*get_prereq_ignoreinst = *libdnf5::rpmc::Package_get_prereq_ignoreinst;
*get_regular_requires = *libdnf5::rpmc::Package_get_regular_requires;
*get_recommends = *libdnf5::rpmc::Package_get_recommends;
*get_suggests = *libdnf5::rpmc::Package_get_suggests;
*get_enhances = *libdnf5::rpmc::Package_get_enhances;
*get_supplements = *libdnf5::rpmc::Package_get_supplements;
*get_depends = *libdnf5::rpmc::Package_get_depends;
*get_files = *libdnf5::rpmc::Package_get_files;
*get_changelogs = *libdnf5::rpmc::Package_get_changelogs;
*get_baseurl = *libdnf5::rpmc::Package_get_baseurl;
*get_location = *libdnf5::rpmc::Package_get_location;
*get_remote_locations = *libdnf5::rpmc::Package_get_remote_locations;
*get_checksum = *libdnf5::rpmc::Package_get_checksum;
*get_hdr_checksum = *libdnf5::rpmc::Package_get_hdr_checksum;
*get_hdr_end = *libdnf5::rpmc::Package_get_hdr_end;
*get_media_number = *libdnf5::rpmc::Package_get_media_number;
*get_package_path = *libdnf5::rpmc::Package_get_package_path;
*is_available_locally = *libdnf5::rpmc::Package_is_available_locally;
*is_installed = *libdnf5::rpmc::Package_is_installed;
*is_excluded = *libdnf5::rpmc::Package_is_excluded;
*get_from_repo_id = *libdnf5::rpmc::Package_get_from_repo_id;
*get_install_time = *libdnf5::rpmc::Package_get_install_time;
*get_rpmdbid = *libdnf5::rpmc::Package_get_rpmdbid;
*get_repo = *libdnf5::rpmc::Package_get_repo;
*is_pkg_gpgcheck_enabled = *libdnf5::rpmc::Package_is_pkg_gpgcheck_enabled;
*get_repo_id = *libdnf5::rpmc::Package_get_repo_id;
*get_repo_name = *libdnf5::rpmc::Package_get_repo_name;
*get_reason = *libdnf5::rpmc::Package_get_reason;
*get_base = *libdnf5::rpmc::Package_get_base;
*to_string = *libdnf5::rpmc::Package_to_string;
*to_string_description = *libdnf5::rpmc::Package_to_string_description;
*get_hash = *libdnf5::rpmc::Package_get_hash;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorPackage ##############

package libdnf5::rpm::VectorPackage;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorPackage(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorPackage_size;
*empty = *libdnf5::rpmc::VectorPackage_empty;
*clear = *libdnf5::rpmc::VectorPackage_clear;
*push = *libdnf5::rpmc::VectorPackage_push;
*pop = *libdnf5::rpmc::VectorPackage_pop;
*get = *libdnf5::rpmc::VectorPackage_get;
*set = *libdnf5::rpmc::VectorPackage_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorPackage($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorVectorPackage ##############

package libdnf5::rpm::VectorVectorPackage;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorVectorPackage(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorVectorPackage_size;
*empty = *libdnf5::rpmc::VectorVectorPackage_empty;
*clear = *libdnf5::rpmc::VectorVectorPackage_clear;
*push = *libdnf5::rpmc::VectorVectorPackage_push;
*pop = *libdnf5::rpmc::VectorVectorPackage_pop;
*get = *libdnf5::rpmc::VectorVectorPackage_get;
*set = *libdnf5::rpmc::VectorVectorPackage_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorVectorPackage($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorChangelog ##############

package libdnf5::rpm::VectorChangelog;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorChangelog(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorChangelog_size;
*empty = *libdnf5::rpmc::VectorChangelog_empty;
*clear = *libdnf5::rpmc::VectorChangelog_clear;
*push = *libdnf5::rpmc::VectorChangelog_push;
*pop = *libdnf5::rpmc::VectorChangelog_pop;
*get = *libdnf5::rpmc::VectorChangelog_get;
*set = *libdnf5::rpmc::VectorChangelog_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorChangelog($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PackageSetIterator ##############

package libdnf5::rpm::PackageSetIterator;
use overload
    "!=" => sub { $_[0]->__ne__($_[1])},
    "++" => sub { $_[0]->__plusplus__()},
    "==" => sub { $_[0]->__eq__($_[1])},
    "=" => sub { my $class = ref($_[0]); $class->new($_[0]) },
    "fallback" => 1;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PackageSetIterator(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PackageSetIterator($self);
        delete $OWNER{$self};
    }
}

*value = *libdnf5::rpmc::PackageSetIterator_value;
*next = *libdnf5::rpmc::PackageSetIterator_next;
*__plusplus__ = *libdnf5::rpmc::PackageSetIterator___plusplus__;
*__eq__ = *libdnf5::rpmc::PackageSetIterator___eq__;
*__ne__ = *libdnf5::rpmc::PackageSetIterator___ne__;
*begin = *libdnf5::rpmc::PackageSetIterator_begin;
*end = *libdnf5::rpmc::PackageSetIterator_end;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PackageSet ##############

package libdnf5::rpm::PackageSet;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PackageSet(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PackageSet($self);
        delete $OWNER{$self};
    }
}

*begin = *libdnf5::rpmc::PackageSet_begin;
*end = *libdnf5::rpmc::PackageSet_end;
*__isub__ = *libdnf5::rpmc::PackageSet___isub__;
*update = *libdnf5::rpmc::PackageSet_update;
*intersection = *libdnf5::rpmc::PackageSet_intersection;
*difference = *libdnf5::rpmc::PackageSet_difference;
*clear = *libdnf5::rpmc::PackageSet_clear;
*empty = *libdnf5::rpmc::PackageSet_empty;
*add = *libdnf5::rpmc::PackageSet_add;
*contains = *libdnf5::rpmc::PackageSet_contains;
*remove = *libdnf5::rpmc::PackageSet_remove;
*get_base = *libdnf5::rpmc::PackageSet_get_base;
*size = *libdnf5::rpmc::PackageSet_size;
*swap = *libdnf5::rpmc::PackageSet_swap;
*to_sorted_vector = *libdnf5::rpmc::PackageSet_to_sorted_vector;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::PackageQuery ##############

package libdnf5::rpm::PackageQuery;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm::PackageSet libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_PackageQuery(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_PackageQuery($self);
        delete $OWNER{$self};
    }
}

*filter_name = *libdnf5::rpmc::PackageQuery_filter_name;
*filter_epoch = *libdnf5::rpmc::PackageQuery_filter_epoch;
*filter_version = *libdnf5::rpmc::PackageQuery_filter_version;
*filter_release = *libdnf5::rpmc::PackageQuery_filter_release;
*filter_arch = *libdnf5::rpmc::PackageQuery_filter_arch;
*filter_vendor = *libdnf5::rpmc::PackageQuery_filter_vendor;
*filter_name_arch = *libdnf5::rpmc::PackageQuery_filter_name_arch;
*filter_evr = *libdnf5::rpmc::PackageQuery_filter_evr;
*filter_nevra = *libdnf5::rpmc::PackageQuery_filter_nevra;
*filter_sourcerpm = *libdnf5::rpmc::PackageQuery_filter_sourcerpm;
*filter_url = *libdnf5::rpmc::PackageQuery_filter_url;
*filter_summary = *libdnf5::rpmc::PackageQuery_filter_summary;
*filter_description = *libdnf5::rpmc::PackageQuery_filter_description;
*filter_provides = *libdnf5::rpmc::PackageQuery_filter_provides;
*filter_requires = *libdnf5::rpmc::PackageQuery_filter_requires;
*filter_conflicts = *libdnf5::rpmc::PackageQuery_filter_conflicts;
*filter_obsoletes = *libdnf5::rpmc::PackageQuery_filter_obsoletes;
*filter_recommends = *libdnf5::rpmc::PackageQuery_filter_recommends;
*filter_suggests = *libdnf5::rpmc::PackageQuery_filter_suggests;
*filter_enhances = *libdnf5::rpmc::PackageQuery_filter_enhances;
*filter_supplements = *libdnf5::rpmc::PackageQuery_filter_supplements;
*filter_file = *libdnf5::rpmc::PackageQuery_filter_file;
*filter_location = *libdnf5::rpmc::PackageQuery_filter_location;
*filter_checksum = *libdnf5::rpmc::PackageQuery_filter_checksum;
*filter_repo_id = *libdnf5::rpmc::PackageQuery_filter_repo_id;
*filter_from_repo_id = *libdnf5::rpmc::PackageQuery_filter_from_repo_id;
*filter_advisories = *libdnf5::rpmc::PackageQuery_filter_advisories;
*filter_latest_unresolved_advisories = *libdnf5::rpmc::PackageQuery_filter_latest_unresolved_advisories;
*filter_installed = *libdnf5::rpmc::PackageQuery_filter_installed;
*filter_available = *libdnf5::rpmc::PackageQuery_filter_available;
*filter_upgrades = *libdnf5::rpmc::PackageQuery_filter_upgrades;
*filter_downgrades = *libdnf5::rpmc::PackageQuery_filter_downgrades;
*filter_upgradable = *libdnf5::rpmc::PackageQuery_filter_upgradable;
*filter_downgradable = *libdnf5::rpmc::PackageQuery_filter_downgradable;
*filter_latest_evr = *libdnf5::rpmc::PackageQuery_filter_latest_evr;
*filter_latest_evr_any_arch = *libdnf5::rpmc::PackageQuery_filter_latest_evr_any_arch;
*filter_earliest_evr = *libdnf5::rpmc::PackageQuery_filter_earliest_evr;
*filter_earliest_evr_any_arch = *libdnf5::rpmc::PackageQuery_filter_earliest_evr_any_arch;
*filter_priority = *libdnf5::rpmc::PackageQuery_filter_priority;
*filter_extras = *libdnf5::rpmc::PackageQuery_filter_extras;
*filter_recent = *libdnf5::rpmc::PackageQuery_filter_recent;
*filter_userinstalled = *libdnf5::rpmc::PackageQuery_filter_userinstalled;
*filter_unneeded = *libdnf5::rpmc::PackageQuery_filter_unneeded;
*filter_unneeded_not_protected = *libdnf5::rpmc::PackageQuery_filter_unneeded_not_protected;
*resolve_pkg_spec = *libdnf5::rpmc::PackageQuery_resolve_pkg_spec;
*is_dep_satisfied = *libdnf5::rpmc::PackageQuery_is_dep_satisfied;
*swap = *libdnf5::rpmc::PackageQuery_swap;
*filter_duplicates = *libdnf5::rpmc::PackageQuery_filter_duplicates;
*filter_leaves = *libdnf5::rpmc::PackageQuery_filter_leaves;
*filter_reboot_suggested = *libdnf5::rpmc::PackageQuery_filter_reboot_suggested;
*filter_leaves_groups = *libdnf5::rpmc::PackageQuery_filter_leaves_groups;
*filter_installonly = *libdnf5::rpmc::PackageQuery_filter_installonly;
*filter_versionlock = *libdnf5::rpmc::PackageQuery_filter_versionlock;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::TransactionCallbacks ##############

package libdnf5::rpm::TransactionCallbacks;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*ScriptType_UNKNOWN = *libdnf5::rpmc::TransactionCallbacks_ScriptType_UNKNOWN;
*ScriptType_PRE_INSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_PRE_INSTALL;
*ScriptType_POST_INSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_POST_INSTALL;
*ScriptType_PRE_UNINSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_PRE_UNINSTALL;
*ScriptType_POST_UNINSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_POST_UNINSTALL;
*ScriptType_PRE_TRANSACTION = *libdnf5::rpmc::TransactionCallbacks_ScriptType_PRE_TRANSACTION;
*ScriptType_POST_TRANSACTION = *libdnf5::rpmc::TransactionCallbacks_ScriptType_POST_TRANSACTION;
*ScriptType_TRIGGER_PRE_INSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_TRIGGER_PRE_INSTALL;
*ScriptType_TRIGGER_INSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_TRIGGER_INSTALL;
*ScriptType_TRIGGER_UNINSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_TRIGGER_UNINSTALL;
*ScriptType_TRIGGER_POST_UNINSTALL = *libdnf5::rpmc::TransactionCallbacks_ScriptType_TRIGGER_POST_UNINSTALL;
*ScriptType_SYSUSERS = *libdnf5::rpmc::TransactionCallbacks_ScriptType_SYSUSERS;
*ScriptType_PREUN_TRANSACTION = *libdnf5::rpmc::TransactionCallbacks_ScriptType_PREUN_TRANSACTION;
*ScriptType_POSTUN_TRANSACTION = *libdnf5::rpmc::TransactionCallbacks_ScriptType_POSTUN_TRANSACTION;
*script_type_to_string = *libdnf5::rpmc::TransactionCallbacks_script_type_to_string;
sub new {
    my $pkg = $_[0];
    my $self = libdnf5::rpmc::new_TransactionCallbacks(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_TransactionCallbacks($self);
        delete $OWNER{$self};
    }
}

*before_begin = *libdnf5::rpmc::TransactionCallbacks_before_begin;
*after_complete = *libdnf5::rpmc::TransactionCallbacks_after_complete;
*install_progress = *libdnf5::rpmc::TransactionCallbacks_install_progress;
*install_start = *libdnf5::rpmc::TransactionCallbacks_install_start;
*install_stop = *libdnf5::rpmc::TransactionCallbacks_install_stop;
*transaction_progress = *libdnf5::rpmc::TransactionCallbacks_transaction_progress;
*transaction_start = *libdnf5::rpmc::TransactionCallbacks_transaction_start;
*transaction_stop = *libdnf5::rpmc::TransactionCallbacks_transaction_stop;
*uninstall_progress = *libdnf5::rpmc::TransactionCallbacks_uninstall_progress;
*uninstall_start = *libdnf5::rpmc::TransactionCallbacks_uninstall_start;
*uninstall_stop = *libdnf5::rpmc::TransactionCallbacks_uninstall_stop;
*unpack_error = *libdnf5::rpmc::TransactionCallbacks_unpack_error;
*cpio_error = *libdnf5::rpmc::TransactionCallbacks_cpio_error;
*script_error = *libdnf5::rpmc::TransactionCallbacks_script_error;
*script_start = *libdnf5::rpmc::TransactionCallbacks_script_start;
*script_stop = *libdnf5::rpmc::TransactionCallbacks_script_stop;
*elem_progress = *libdnf5::rpmc::TransactionCallbacks_elem_progress;
*verify_progress = *libdnf5::rpmc::TransactionCallbacks_verify_progress;
*verify_start = *libdnf5::rpmc::TransactionCallbacks_verify_start;
*verify_stop = *libdnf5::rpmc::TransactionCallbacks_verify_stop;
sub DISOWN {
    my $self = shift;
    libdnf5::rpmc::disown_TransactionCallbacks($self);
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    if (not $self->can($member_func)) {
        my $h = libdnf5::rpmc::swig_get_attr_TransactionCallbacks($self);
        return $h->{$field} if $h;
    }
    return $self->$member_func;
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    if (not $self->can($member_func)) {
        my $h = libdnf5::rpmc::swig_get_attr_TransactionCallbacks($self);
        return $h->{$field} = $newval if $h;
    }
    return $self->$member_func($newval);
}

############# Class : libdnf5::rpm::TransactionCallbacksUniquePtr ##############

package libdnf5::rpm::TransactionCallbacksUniquePtr;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_TransactionCallbacksUniquePtr(@_);
    bless $self, $pkg if defined($self);
}

*__deref__ = *libdnf5::rpmc::TransactionCallbacksUniquePtr___deref__;
*release = *libdnf5::rpmc::TransactionCallbacksUniquePtr_release;
*reset = *libdnf5::rpmc::TransactionCallbacksUniquePtr_reset;
*swap = *libdnf5::rpmc::TransactionCallbacksUniquePtr_swap;
*get = *libdnf5::rpmc::TransactionCallbacksUniquePtr_get;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_TransactionCallbacksUniquePtr($self);
        delete $OWNER{$self};
    }
}

*script_type_to_string = *libdnf5::rpmc::TransactionCallbacksUniquePtr_script_type_to_string;
*before_begin = *libdnf5::rpmc::TransactionCallbacksUniquePtr_before_begin;
*after_complete = *libdnf5::rpmc::TransactionCallbacksUniquePtr_after_complete;
*install_progress = *libdnf5::rpmc::TransactionCallbacksUniquePtr_install_progress;
*install_start = *libdnf5::rpmc::TransactionCallbacksUniquePtr_install_start;
*install_stop = *libdnf5::rpmc::TransactionCallbacksUniquePtr_install_stop;
*transaction_progress = *libdnf5::rpmc::TransactionCallbacksUniquePtr_transaction_progress;
*transaction_start = *libdnf5::rpmc::TransactionCallbacksUniquePtr_transaction_start;
*transaction_stop = *libdnf5::rpmc::TransactionCallbacksUniquePtr_transaction_stop;
*uninstall_progress = *libdnf5::rpmc::TransactionCallbacksUniquePtr_uninstall_progress;
*uninstall_start = *libdnf5::rpmc::TransactionCallbacksUniquePtr_uninstall_start;
*uninstall_stop = *libdnf5::rpmc::TransactionCallbacksUniquePtr_uninstall_stop;
*unpack_error = *libdnf5::rpmc::TransactionCallbacksUniquePtr_unpack_error;
*cpio_error = *libdnf5::rpmc::TransactionCallbacksUniquePtr_cpio_error;
*script_error = *libdnf5::rpmc::TransactionCallbacksUniquePtr_script_error;
*script_start = *libdnf5::rpmc::TransactionCallbacksUniquePtr_script_start;
*script_stop = *libdnf5::rpmc::TransactionCallbacksUniquePtr_script_stop;
*elem_progress = *libdnf5::rpmc::TransactionCallbacksUniquePtr_elem_progress;
*verify_progress = *libdnf5::rpmc::TransactionCallbacksUniquePtr_verify_progress;
*verify_start = *libdnf5::rpmc::TransactionCallbacksUniquePtr_verify_start;
*verify_stop = *libdnf5::rpmc::TransactionCallbacksUniquePtr_verify_stop;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::KeyInfo ##############

package libdnf5::rpm::KeyInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*get_key_id = *libdnf5::rpmc::KeyInfo_get_key_id;
*get_short_key_id = *libdnf5::rpmc::KeyInfo_get_short_key_id;
*get_user_ids = *libdnf5::rpmc::KeyInfo_get_user_ids;
*get_fingerprint = *libdnf5::rpmc::KeyInfo_get_fingerprint;
*get_url = *libdnf5::rpmc::KeyInfo_get_url;
*get_path = *libdnf5::rpmc::KeyInfo_get_path;
*get_raw_key = *libdnf5::rpmc::KeyInfo_get_raw_key;
*get_timestamp = *libdnf5::rpmc::KeyInfo_get_timestamp;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_KeyInfo($self);
        delete $OWNER{$self};
    }
}

sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_KeyInfo(@_);
    bless $self, $pkg if defined($self);
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::RpmSignature ##############

package libdnf5::rpm::RpmSignature;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
*CheckResult_OK = *libdnf5::rpmc::RpmSignature_CheckResult_OK;
*CheckResult_SKIPPED = *libdnf5::rpmc::RpmSignature_CheckResult_SKIPPED;
*CheckResult_FAILED_KEY_MISSING = *libdnf5::rpmc::RpmSignature_CheckResult_FAILED_KEY_MISSING;
*CheckResult_FAILED_NOT_TRUSTED = *libdnf5::rpmc::RpmSignature_CheckResult_FAILED_NOT_TRUSTED;
*CheckResult_FAILED_NOT_SIGNED = *libdnf5::rpmc::RpmSignature_CheckResult_FAILED_NOT_SIGNED;
*CheckResult_FAILED = *libdnf5::rpmc::RpmSignature_CheckResult_FAILED;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_RpmSignature($self);
        delete $OWNER{$self};
    }
}

sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_RpmSignature(@_);
    bless $self, $pkg if defined($self);
}

*check_package_signature = *libdnf5::rpmc::RpmSignature_check_package_signature;
*import_key = *libdnf5::rpmc::RpmSignature_import_key;
*key_present = *libdnf5::rpmc::RpmSignature_key_present;
*parse_key_file = *libdnf5::rpmc::RpmSignature_parse_key_file;
*check_result_to_string = *libdnf5::rpmc::RpmSignature_check_result_to_string;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : libdnf5::rpm::VectorKeyInfo ##############

package libdnf5::rpm::VectorKeyInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( libdnf5::rpm );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = libdnf5::rpmc::new_VectorKeyInfo(@_);
    bless $self, $pkg if defined($self);
}

*size = *libdnf5::rpmc::VectorKeyInfo_size;
*empty = *libdnf5::rpmc::VectorKeyInfo_empty;
*clear = *libdnf5::rpmc::VectorKeyInfo_clear;
*push = *libdnf5::rpmc::VectorKeyInfo_push;
*pop = *libdnf5::rpmc::VectorKeyInfo_pop;
*get = *libdnf5::rpmc::VectorKeyInfo_get;
*set = *libdnf5::rpmc::VectorKeyInfo_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        libdnf5::rpmc::delete_VectorKeyInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package libdnf5::rpm;

1;
