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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _solv
else:
    import _solv

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


ID_NULL = _solv.ID_NULL
ID_EMPTY = _solv.ID_EMPTY
SOLVABLE_NAME = _solv.SOLVABLE_NAME
SOLVABLE_ARCH = _solv.SOLVABLE_ARCH
SOLVABLE_EVR = _solv.SOLVABLE_EVR
SOLVABLE_VENDOR = _solv.SOLVABLE_VENDOR
SOLVABLE_PROVIDES = _solv.SOLVABLE_PROVIDES
SOLVABLE_OBSOLETES = _solv.SOLVABLE_OBSOLETES
SOLVABLE_CONFLICTS = _solv.SOLVABLE_CONFLICTS
SOLVABLE_REQUIRES = _solv.SOLVABLE_REQUIRES
SOLVABLE_RECOMMENDS = _solv.SOLVABLE_RECOMMENDS
SOLVABLE_SUGGESTS = _solv.SOLVABLE_SUGGESTS
SOLVABLE_SUPPLEMENTS = _solv.SOLVABLE_SUPPLEMENTS
SOLVABLE_ENHANCES = _solv.SOLVABLE_ENHANCES
RPM_RPMDBID = _solv.RPM_RPMDBID
SOLVABLE_PREREQMARKER = _solv.SOLVABLE_PREREQMARKER
SOLVABLE_FILEMARKER = _solv.SOLVABLE_FILEMARKER
NAMESPACE_INSTALLED = _solv.NAMESPACE_INSTALLED
NAMESPACE_MODALIAS = _solv.NAMESPACE_MODALIAS
NAMESPACE_SPLITPROVIDES = _solv.NAMESPACE_SPLITPROVIDES
NAMESPACE_LANGUAGE = _solv.NAMESPACE_LANGUAGE
NAMESPACE_FILESYSTEM = _solv.NAMESPACE_FILESYSTEM
NAMESPACE_OTHERPROVIDERS = _solv.NAMESPACE_OTHERPROVIDERS
SYSTEM_SYSTEM = _solv.SYSTEM_SYSTEM
ARCH_SRC = _solv.ARCH_SRC
ARCH_NOSRC = _solv.ARCH_NOSRC
ARCH_NOARCH = _solv.ARCH_NOARCH
ARCH_ALL = _solv.ARCH_ALL
ARCH_ANY = _solv.ARCH_ANY
REPOSITORY_SOLVABLES = _solv.REPOSITORY_SOLVABLES
REPOSITORY_DELTAINFO = _solv.REPOSITORY_DELTAINFO
REPOSITORY_EXTERNAL = _solv.REPOSITORY_EXTERNAL
REPOSITORY_KEYS = _solv.REPOSITORY_KEYS
REPOSITORY_LOCATION = _solv.REPOSITORY_LOCATION
REPOKEY_TYPE_VOID = _solv.REPOKEY_TYPE_VOID
REPOKEY_TYPE_CONSTANT = _solv.REPOKEY_TYPE_CONSTANT
REPOKEY_TYPE_CONSTANTID = _solv.REPOKEY_TYPE_CONSTANTID
REPOKEY_TYPE_ID = _solv.REPOKEY_TYPE_ID
REPOKEY_TYPE_NUM = _solv.REPOKEY_TYPE_NUM
REPOKEY_TYPE_DIR = _solv.REPOKEY_TYPE_DIR
REPOKEY_TYPE_STR = _solv.REPOKEY_TYPE_STR
REPOKEY_TYPE_BINARY = _solv.REPOKEY_TYPE_BINARY
REPOKEY_TYPE_IDARRAY = _solv.REPOKEY_TYPE_IDARRAY
REPOKEY_TYPE_REL_IDARRAY = _solv.REPOKEY_TYPE_REL_IDARRAY
REPOKEY_TYPE_DIRSTRARRAY = _solv.REPOKEY_TYPE_DIRSTRARRAY
REPOKEY_TYPE_DIRNUMNUMARRAY = _solv.REPOKEY_TYPE_DIRNUMNUMARRAY
REPOKEY_TYPE_MD5 = _solv.REPOKEY_TYPE_MD5
REPOKEY_TYPE_SHA1 = _solv.REPOKEY_TYPE_SHA1
REPOKEY_TYPE_SHA224 = _solv.REPOKEY_TYPE_SHA224
REPOKEY_TYPE_SHA256 = _solv.REPOKEY_TYPE_SHA256
REPOKEY_TYPE_SHA384 = _solv.REPOKEY_TYPE_SHA384
REPOKEY_TYPE_SHA512 = _solv.REPOKEY_TYPE_SHA512
REPOKEY_TYPE_FIXARRAY = _solv.REPOKEY_TYPE_FIXARRAY
REPOKEY_TYPE_FLEXARRAY = _solv.REPOKEY_TYPE_FLEXARRAY
REPOKEY_TYPE_DELETED = _solv.REPOKEY_TYPE_DELETED
SOLVABLE_SUMMARY = _solv.SOLVABLE_SUMMARY
SOLVABLE_DESCRIPTION = _solv.SOLVABLE_DESCRIPTION
SOLVABLE_DISTRIBUTION = _solv.SOLVABLE_DISTRIBUTION
SOLVABLE_AUTHORS = _solv.SOLVABLE_AUTHORS
SOLVABLE_PACKAGER = _solv.SOLVABLE_PACKAGER
SOLVABLE_GROUP = _solv.SOLVABLE_GROUP
SOLVABLE_URL = _solv.SOLVABLE_URL
SOLVABLE_KEYWORDS = _solv.SOLVABLE_KEYWORDS
SOLVABLE_LICENSE = _solv.SOLVABLE_LICENSE
SOLVABLE_BUILDTIME = _solv.SOLVABLE_BUILDTIME
SOLVABLE_BUILDHOST = _solv.SOLVABLE_BUILDHOST
SOLVABLE_EULA = _solv.SOLVABLE_EULA
SOLVABLE_CPEID = _solv.SOLVABLE_CPEID
SOLVABLE_MESSAGEINS = _solv.SOLVABLE_MESSAGEINS
SOLVABLE_MESSAGEDEL = _solv.SOLVABLE_MESSAGEDEL
SOLVABLE_INSTALLSIZE = _solv.SOLVABLE_INSTALLSIZE
SOLVABLE_DISKUSAGE = _solv.SOLVABLE_DISKUSAGE
SOLVABLE_FILELIST = _solv.SOLVABLE_FILELIST
SOLVABLE_INSTALLTIME = _solv.SOLVABLE_INSTALLTIME
SOLVABLE_MEDIADIR = _solv.SOLVABLE_MEDIADIR
SOLVABLE_MEDIAFILE = _solv.SOLVABLE_MEDIAFILE
SOLVABLE_MEDIANR = _solv.SOLVABLE_MEDIANR
SOLVABLE_MEDIABASE = _solv.SOLVABLE_MEDIABASE
SOLVABLE_DOWNLOADSIZE = _solv.SOLVABLE_DOWNLOADSIZE
SOLVABLE_SOURCEARCH = _solv.SOLVABLE_SOURCEARCH
SOLVABLE_SOURCENAME = _solv.SOLVABLE_SOURCENAME
SOLVABLE_SOURCEEVR = _solv.SOLVABLE_SOURCEEVR
SOLVABLE_ISVISIBLE = _solv.SOLVABLE_ISVISIBLE
SOLVABLE_TRIGGERS = _solv.SOLVABLE_TRIGGERS
SOLVABLE_CHECKSUM = _solv.SOLVABLE_CHECKSUM
SOLVABLE_PKGID = _solv.SOLVABLE_PKGID
SOLVABLE_HDRID = _solv.SOLVABLE_HDRID
SOLVABLE_LEADSIGID = _solv.SOLVABLE_LEADSIGID
SOLVABLE_PATCHCATEGORY = _solv.SOLVABLE_PATCHCATEGORY
SOLVABLE_HEADEREND = _solv.SOLVABLE_HEADEREND
SOLVABLE_CHANGELOG = _solv.SOLVABLE_CHANGELOG
SOLVABLE_CHANGELOG_AUTHOR = _solv.SOLVABLE_CHANGELOG_AUTHOR
SOLVABLE_CHANGELOG_TIME = _solv.SOLVABLE_CHANGELOG_TIME
SOLVABLE_CHANGELOG_TEXT = _solv.SOLVABLE_CHANGELOG_TEXT
SOLVABLE_INSTALLSTATUS = _solv.SOLVABLE_INSTALLSTATUS
SOLVABLE_PREREQ_IGNOREINST = _solv.SOLVABLE_PREREQ_IGNOREINST
SOLVABLE_CATEGORY = _solv.SOLVABLE_CATEGORY
SOLVABLE_INCLUDES = _solv.SOLVABLE_INCLUDES
SOLVABLE_EXTENDS = _solv.SOLVABLE_EXTENDS
SOLVABLE_ICON = _solv.SOLVABLE_ICON
SOLVABLE_ORDER = _solv.SOLVABLE_ORDER
UPDATE_REBOOT = _solv.UPDATE_REBOOT
UPDATE_RESTART = _solv.UPDATE_RESTART
UPDATE_RELOGIN = _solv.UPDATE_RELOGIN
UPDATE_MESSAGE = _solv.UPDATE_MESSAGE
UPDATE_SEVERITY = _solv.UPDATE_SEVERITY
UPDATE_RIGHTS = _solv.UPDATE_RIGHTS
UPDATE_COLLECTION = _solv.UPDATE_COLLECTION
UPDATE_COLLECTION_NAME = _solv.UPDATE_COLLECTION_NAME
UPDATE_COLLECTION_EVR = _solv.UPDATE_COLLECTION_EVR
UPDATE_COLLECTION_ARCH = _solv.UPDATE_COLLECTION_ARCH
UPDATE_COLLECTION_FILENAME = _solv.UPDATE_COLLECTION_FILENAME
UPDATE_COLLECTION_FLAGS = _solv.UPDATE_COLLECTION_FLAGS
UPDATE_REFERENCE = _solv.UPDATE_REFERENCE
UPDATE_REFERENCE_TYPE = _solv.UPDATE_REFERENCE_TYPE
UPDATE_REFERENCE_HREF = _solv.UPDATE_REFERENCE_HREF
UPDATE_REFERENCE_ID = _solv.UPDATE_REFERENCE_ID
UPDATE_REFERENCE_TITLE = _solv.UPDATE_REFERENCE_TITLE
PRODUCT_REFERENCEFILE = _solv.PRODUCT_REFERENCEFILE
PRODUCT_SHORTLABEL = _solv.PRODUCT_SHORTLABEL
PRODUCT_DISTPRODUCT = _solv.PRODUCT_DISTPRODUCT
PRODUCT_DISTVERSION = _solv.PRODUCT_DISTVERSION
PRODUCT_TYPE = _solv.PRODUCT_TYPE
PRODUCT_URL = _solv.PRODUCT_URL
PRODUCT_URL_TYPE = _solv.PRODUCT_URL_TYPE
PRODUCT_FLAGS = _solv.PRODUCT_FLAGS
PRODUCT_PRODUCTLINE = _solv.PRODUCT_PRODUCTLINE
PRODUCT_REGISTER_TARGET = _solv.PRODUCT_REGISTER_TARGET
PRODUCT_REGISTER_FLAVOR = _solv.PRODUCT_REGISTER_FLAVOR
PRODUCT_REGISTER_RELEASE = _solv.PRODUCT_REGISTER_RELEASE
PRODUCT_UPDATES_REPOID = _solv.PRODUCT_UPDATES_REPOID
PRODUCT_UPDATES = _solv.PRODUCT_UPDATES
PRODUCT_ENDOFLIFE = _solv.PRODUCT_ENDOFLIFE
SUSETAGS_DATADIR = _solv.SUSETAGS_DATADIR
SUSETAGS_DESCRDIR = _solv.SUSETAGS_DESCRDIR
SUSETAGS_DEFAULTVENDOR = _solv.SUSETAGS_DEFAULTVENDOR
SUSETAGS_FILE = _solv.SUSETAGS_FILE
SUSETAGS_FILE_NAME = _solv.SUSETAGS_FILE_NAME
SUSETAGS_FILE_TYPE = _solv.SUSETAGS_FILE_TYPE
SUSETAGS_FILE_CHECKSUM = _solv.SUSETAGS_FILE_CHECKSUM
SUSETAGS_SHARE_NAME = _solv.SUSETAGS_SHARE_NAME
SUSETAGS_SHARE_EVR = _solv.SUSETAGS_SHARE_EVR
SUSETAGS_SHARE_ARCH = _solv.SUSETAGS_SHARE_ARCH
REPOSITORY_ADDEDFILEPROVIDES = _solv.REPOSITORY_ADDEDFILEPROVIDES
REPOSITORY_RPMDBCOOKIE = _solv.REPOSITORY_RPMDBCOOKIE
REPOSITORY_FILTEREDFILELIST = _solv.REPOSITORY_FILTEREDFILELIST
REPOSITORY_TIMESTAMP = _solv.REPOSITORY_TIMESTAMP
REPOSITORY_EXPIRE = _solv.REPOSITORY_EXPIRE
REPOSITORY_UPDATES = _solv.REPOSITORY_UPDATES
REPOSITORY_DISTROS = _solv.REPOSITORY_DISTROS
REPOSITORY_PRODUCT_LABEL = _solv.REPOSITORY_PRODUCT_LABEL
REPOSITORY_PRODUCT_CPEID = _solv.REPOSITORY_PRODUCT_CPEID
REPOSITORY_REPOID = _solv.REPOSITORY_REPOID
REPOSITORY_KEYWORDS = _solv.REPOSITORY_KEYWORDS
REPOSITORY_REVISION = _solv.REPOSITORY_REVISION
REPOSITORY_TOOLVERSION = _solv.REPOSITORY_TOOLVERSION
DELTA_PACKAGE_NAME = _solv.DELTA_PACKAGE_NAME
DELTA_PACKAGE_EVR = _solv.DELTA_PACKAGE_EVR
DELTA_PACKAGE_ARCH = _solv.DELTA_PACKAGE_ARCH
DELTA_LOCATION_DIR = _solv.DELTA_LOCATION_DIR
DELTA_LOCATION_NAME = _solv.DELTA_LOCATION_NAME
DELTA_LOCATION_EVR = _solv.DELTA_LOCATION_EVR
DELTA_LOCATION_SUFFIX = _solv.DELTA_LOCATION_SUFFIX
DELTA_DOWNLOADSIZE = _solv.DELTA_DOWNLOADSIZE
DELTA_CHECKSUM = _solv.DELTA_CHECKSUM
DELTA_BASE_EVR = _solv.DELTA_BASE_EVR
DELTA_SEQ_NAME = _solv.DELTA_SEQ_NAME
DELTA_SEQ_EVR = _solv.DELTA_SEQ_EVR
DELTA_SEQ_NUM = _solv.DELTA_SEQ_NUM
DELTA_LOCATION_BASE = _solv.DELTA_LOCATION_BASE
REPOSITORY_REPOMD = _solv.REPOSITORY_REPOMD
REPOSITORY_REPOMD_TYPE = _solv.REPOSITORY_REPOMD_TYPE
REPOSITORY_REPOMD_LOCATION = _solv.REPOSITORY_REPOMD_LOCATION
REPOSITORY_REPOMD_TIMESTAMP = _solv.REPOSITORY_REPOMD_TIMESTAMP
REPOSITORY_REPOMD_CHECKSUM = _solv.REPOSITORY_REPOMD_CHECKSUM
REPOSITORY_REPOMD_OPENCHECKSUM = _solv.REPOSITORY_REPOMD_OPENCHECKSUM
REPOSITORY_REPOMD_SIZE = _solv.REPOSITORY_REPOMD_SIZE
PUBKEY_KEYID = _solv.PUBKEY_KEYID
PUBKEY_FINGERPRINT = _solv.PUBKEY_FINGERPRINT
PUBKEY_EXPIRES = _solv.PUBKEY_EXPIRES
PUBKEY_SIGNATURES = _solv.PUBKEY_SIGNATURES
PUBKEY_DATA = _solv.PUBKEY_DATA
PUBKEY_SUBKEYOF = _solv.PUBKEY_SUBKEYOF
SIGNATURE_ISSUER = _solv.SIGNATURE_ISSUER
SIGNATURE_TIME = _solv.SIGNATURE_TIME
SIGNATURE_EXPIRES = _solv.SIGNATURE_EXPIRES
SIGNATURE_DATA = _solv.SIGNATURE_DATA
UPDATE_MODULE = _solv.UPDATE_MODULE
UPDATE_MODULE_NAME = _solv.UPDATE_MODULE_NAME
UPDATE_MODULE_STREAM = _solv.UPDATE_MODULE_STREAM
UPDATE_MODULE_VERSION = _solv.UPDATE_MODULE_VERSION
UPDATE_MODULE_CONTEXT = _solv.UPDATE_MODULE_CONTEXT
UPDATE_MODULE_ARCH = _solv.UPDATE_MODULE_ARCH
SOLVABLE_BUILDVERSION = _solv.SOLVABLE_BUILDVERSION
SOLVABLE_BUILDFLAVOR = _solv.SOLVABLE_BUILDFLAVOR
UPDATE_STATUS = _solv.UPDATE_STATUS
LIBSOLV_SELF_DESTRUCT_PKG = _solv.LIBSOLV_SELF_DESTRUCT_PKG
SOLVABLE_CONSTRAINS = _solv.SOLVABLE_CONSTRAINS
SOLVABLE_TRACK_FEATURES = _solv.SOLVABLE_TRACK_FEATURES
SOLVABLE_ISDEFAULT = _solv.SOLVABLE_ISDEFAULT
SOLVABLE_LANGONLY = _solv.SOLVABLE_LANGONLY
UPDATE_COLLECTIONLIST = _solv.UPDATE_COLLECTIONLIST
SOLVABLE_MULTIARCH = _solv.SOLVABLE_MULTIARCH
SOLVABLE_SIGNATUREDATA = _solv.SOLVABLE_SIGNATUREDATA
SOLVABLE_ORDERWITHREQUIRES = _solv.SOLVABLE_ORDERWITHREQUIRES
ID_NUM_INTERNAL = _solv.ID_NUM_INTERNAL
SOLVID_META = _solv.SOLVID_META
SOLVID_POS = _solv.SOLVID_POS
REL_EQ = _solv.REL_EQ
REL_GT = _solv.REL_GT
REL_LT = _solv.REL_LT
REL_AND = _solv.REL_AND
REL_OR = _solv.REL_OR
REL_WITH = _solv.REL_WITH
REL_NAMESPACE = _solv.REL_NAMESPACE
REL_ARCH = _solv.REL_ARCH
REL_FILECONFLICT = _solv.REL_FILECONFLICT
REL_COND = _solv.REL_COND
REL_COMPAT = _solv.REL_COMPAT
REL_KIND = _solv.REL_KIND
REL_MULTIARCH = _solv.REL_MULTIARCH
REL_ELSE = _solv.REL_ELSE
REL_ERROR = _solv.REL_ERROR
REL_WITHOUT = _solv.REL_WITHOUT
REL_UNLESS = _solv.REL_UNLESS
REL_CONDA = _solv.REL_CONDA
class Selection(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    pool = property(_solv.Selection_pool_get)
    flags = property(_solv.Selection_flags_get)
    SELECTION_NAME = _solv.Selection_SELECTION_NAME
    SELECTION_PROVIDES = _solv.Selection_SELECTION_PROVIDES
    SELECTION_FILELIST = _solv.Selection_SELECTION_FILELIST
    SELECTION_CANON = _solv.Selection_SELECTION_CANON
    SELECTION_DOTARCH = _solv.Selection_SELECTION_DOTARCH
    SELECTION_REL = _solv.Selection_SELECTION_REL
    SELECTION_INSTALLED_ONLY = _solv.Selection_SELECTION_INSTALLED_ONLY
    SELECTION_GLOB = _solv.Selection_SELECTION_GLOB
    SELECTION_FLAT = _solv.Selection_SELECTION_FLAT
    SELECTION_NOCASE = _solv.Selection_SELECTION_NOCASE
    SELECTION_SKIP_KIND = _solv.Selection_SELECTION_SKIP_KIND
    SELECTION_MATCH_DEPSTR = _solv.Selection_SELECTION_MATCH_DEPSTR
    SELECTION_SOURCE_ONLY = _solv.Selection_SELECTION_SOURCE_ONLY
    SELECTION_WITH_SOURCE = _solv.Selection_SELECTION_WITH_SOURCE
    SELECTION_WITH_DISABLED = _solv.Selection_SELECTION_WITH_DISABLED
    SELECTION_WITH_BADARCH = _solv.Selection_SELECTION_WITH_BADARCH
    SELECTION_WITH_ALL = _solv.Selection_SELECTION_WITH_ALL
    SELECTION_ADD = _solv.Selection_SELECTION_ADD
    SELECTION_SUBTRACT = _solv.Selection_SELECTION_SUBTRACT
    SELECTION_FILTER = _solv.Selection_SELECTION_FILTER
    SELECTION_FILTER_KEEP_IFEMPTY = _solv.Selection_SELECTION_FILTER_KEEP_IFEMPTY
    SELECTION_FILTER_SWAPPED = _solv.Selection_SELECTION_FILTER_SWAPPED

    def __init__(self, pool):
        _solv.Selection_swiginit(self, _solv.new_Selection(pool))
    __swig_destroy__ = _solv.delete_Selection

    def isempty(self):
        return _solv.Selection_isempty(self)

    def clone(self, flags=0):
        return _solv.Selection_clone(self, flags)

    def filter(self, lsel):
        return _solv.Selection_filter(self, lsel)

    def add(self, lsel):
        return _solv.Selection_add(self, lsel)

    def add_raw(self, how, what):
        return _solv.Selection_add_raw(self, how, what)

    def subtract(self, lsel):
        return _solv.Selection_subtract(self, lsel)

    def select(self, name, flags):
        return _solv.Selection_select(self, name, flags)

    def matchdeps(self, name, flags, keyname, marker=-1):
        return _solv.Selection_matchdeps(self, name, flags, keyname, marker)

    def matchdepid(self, dep, flags, keyname, marker=-1):
        return _solv.Selection_matchdepid(self, dep, flags, keyname, marker)

    def matchsolvable(self, solvable, flags, keyname, marker=-1):
        return _solv.Selection_matchsolvable(self, solvable, flags, keyname, marker)

    def jobs(self, flags):
        return _solv.Selection_jobs(self, flags)

    def solvables(self):
        return _solv.Selection_solvables(self)

    def __str__(self):
        return _solv.Selection___str__(self)

    def __repr__(self):
        return _solv.Selection___repr__(self)

# Register Selection in _solv:
_solv.Selection_swigregister(Selection)
class Dep(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    pool = property(_solv.Dep_pool_get)
    id = property(_solv.Dep_id_get)

    def __init__(self, pool, id):
        _solv.Dep_swiginit(self, _solv.new_Dep(pool, id))

    def Rel(self, flags, evrid, create=True):
        return _solv.Dep_Rel(self, flags, evrid, create)

    def Selection_name(self, setflags=0):
        return _solv.Dep_Selection_name(self, setflags)

    def Selection_provides(self, setflags=0):
        return _solv.Dep_Selection_provides(self, setflags)

    def str(self):
        return _solv.Dep_str(self)

    def __eq__(self, s):
        return _solv.Dep___eq__(self, s)

    def __ne__(self, s):
        return _solv.Dep___ne__(self, s)

    def __hash__(self):
        return _solv.Dep___hash__(self)

    def __str__(self):
        return _solv.Dep___str__(self)

    def __repr__(self):
        return _solv.Dep___repr__(self)
    __swig_destroy__ = _solv.delete_Dep

# Register Dep in _solv:
_solv.Dep_swigregister(Dep)
class Dataiterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SEARCH_STRING = _solv.Dataiterator_SEARCH_STRING
    SEARCH_STRINGSTART = _solv.Dataiterator_SEARCH_STRINGSTART
    SEARCH_STRINGEND = _solv.Dataiterator_SEARCH_STRINGEND
    SEARCH_SUBSTRING = _solv.Dataiterator_SEARCH_SUBSTRING
    SEARCH_GLOB = _solv.Dataiterator_SEARCH_GLOB
    SEARCH_REGEX = _solv.Dataiterator_SEARCH_REGEX
    SEARCH_NOCASE = _solv.Dataiterator_SEARCH_NOCASE
    SEARCH_FILES = _solv.Dataiterator_SEARCH_FILES
    SEARCH_COMPLETE_FILELIST = _solv.Dataiterator_SEARCH_COMPLETE_FILELIST
    SEARCH_CHECKSUMS = _solv.Dataiterator_SEARCH_CHECKSUMS

    def __init__(self, pool, repo, p, key, match, flags):
        _solv.Dataiterator_swiginit(self, _solv.new_Dataiterator(pool, repo, p, key, match, flags))
    __swig_destroy__ = _solv.delete_Dataiterator

    def __iter__(self): return self


    def __next__(self):
        return _solv.Dataiterator___next__(self)

    def prepend_keyname(self, key):
        return _solv.Dataiterator_prepend_keyname(self, key)

    def skip_solvable(self):
        return _solv.Dataiterator_skip_solvable(self)

# Register Dataiterator in _solv:
_solv.Dataiterator_swigregister(Dataiterator)
class XSolvable(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    pool = property(_solv.XSolvable_pool_get)
    id = property(_solv.XSolvable_id_get)

    def __init__(self, pool, id):
        _solv.XSolvable_swiginit(self, _solv.new_XSolvable(pool, id))

    def str(self):
        return _solv.XSolvable_str(self)

    def lookup_str(self, keyname):
        return _solv.XSolvable_lookup_str(self, keyname)

    def lookup_id(self, keyname):
        return _solv.XSolvable_lookup_id(self, keyname)

    def lookup_num(self, keyname, notfound=0):
        return _solv.XSolvable_lookup_num(self, keyname, notfound)

    def lookup_void(self, keyname):
        return _solv.XSolvable_lookup_void(self, keyname)

    def lookup_checksum(self, keyname):
        return _solv.XSolvable_lookup_checksum(self, keyname)

    def lookup_idarray(self, keyname, marker=-1):
        return _solv.XSolvable_lookup_idarray(self, keyname, marker)

    def lookup_deparray(self, keyname, marker=-1):
        return _solv.XSolvable_lookup_deparray(self, keyname, marker)

    def lookup_location(self):
        return _solv.XSolvable_lookup_location(self)

    def lookup_sourcepkg(self):
        return _solv.XSolvable_lookup_sourcepkg(self)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.XSolvable_Dataiterator(self, key, match, flags)

    def installable(self):
        return _solv.XSolvable_installable(self)

    def isinstalled(self):
        return _solv.XSolvable_isinstalled(self)
    name = property(_solv.XSolvable_name_get, _solv.XSolvable_name_set)
    nameid = property(_solv.XSolvable_nameid_get, _solv.XSolvable_nameid_set)
    evr = property(_solv.XSolvable_evr_get, _solv.XSolvable_evr_set)
    evrid = property(_solv.XSolvable_evrid_get, _solv.XSolvable_evrid_set)
    arch = property(_solv.XSolvable_arch_get, _solv.XSolvable_arch_set)
    archid = property(_solv.XSolvable_archid_get, _solv.XSolvable_archid_set)
    vendor = property(_solv.XSolvable_vendor_get, _solv.XSolvable_vendor_set)
    vendorid = property(_solv.XSolvable_vendorid_get, _solv.XSolvable_vendorid_set)
    repo = property(_solv.XSolvable_repo_get)

    def add_provides(self, id, marker=-1):
        return _solv.XSolvable_add_provides(self, id, marker)

    def add_obsoletes(self, id):
        return _solv.XSolvable_add_obsoletes(self, id)

    def add_conflicts(self, id):
        return _solv.XSolvable_add_conflicts(self, id)

    def add_requires(self, id, marker=-1):
        return _solv.XSolvable_add_requires(self, id, marker)

    def add_recommends(self, id):
        return _solv.XSolvable_add_recommends(self, id)

    def add_suggests(self, id):
        return _solv.XSolvable_add_suggests(self, id)

    def add_supplements(self, id):
        return _solv.XSolvable_add_supplements(self, id)

    def add_enhances(self, id):
        return _solv.XSolvable_add_enhances(self, id)

    def unset(self, keyname):
        return _solv.XSolvable_unset(self, keyname)

    def add_deparray(self, keyname, id, marker=-1):
        return _solv.XSolvable_add_deparray(self, keyname, id, marker)

    def Selection(self, setflags=0):
        return _solv.XSolvable_Selection(self, setflags)

    def identical(self, s2):
        return _solv.XSolvable_identical(self, s2)

    def evrcmp(self, s2):
        return _solv.XSolvable_evrcmp(self, s2)

    def matchesdep(self, keyname, id, marker=-1):
        return _solv.XSolvable_matchesdep(self, keyname, id, marker)

    def __eq__(self, s):
        return _solv.XSolvable___eq__(self, s)

    def __ne__(self, s):
        return _solv.XSolvable___ne__(self, s)

    def __hash__(self):
        return _solv.XSolvable___hash__(self)

    def __str__(self):
        return _solv.XSolvable___str__(self)

    def __repr__(self):
        return _solv.XSolvable___repr__(self)
    __swig_destroy__ = _solv.delete_XSolvable

# Register XSolvable in _solv:
_solv.XSolvable_swigregister(XSolvable)
class Ruleinfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    solv = property(_solv.Ruleinfo_solv_get)
    type = property(_solv.Ruleinfo_type_get)
    dep_id = property(_solv.Ruleinfo_dep_id_get)

    def __init__(self, solv, rid, type, source, target, dep_id):
        _solv.Ruleinfo_swiginit(self, _solv.new_Ruleinfo(solv, rid, type, source, target, dep_id))
    solvable = property(_solv.Ruleinfo_solvable_get)
    othersolvable = property(_solv.Ruleinfo_othersolvable_get)
    dep = property(_solv.Ruleinfo_dep_get)

    def problemstr(self):
        return _solv.Ruleinfo_problemstr(self)

    def __str__(self):
        return _solv.Ruleinfo___str__(self)
    __swig_destroy__ = _solv.delete_Ruleinfo

# Register Ruleinfo in _solv:
_solv.Ruleinfo_swigregister(Ruleinfo)
class XRule(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    solv = property(_solv.XRule_solv_get)
    id = property(_solv.XRule_id_get)

    def __init__(self, solv, id):
        _solv.XRule_swiginit(self, _solv.new_XRule(solv, id))
    type = property(_solv.XRule_type_get)

    def info(self):
        return _solv.XRule_info(self)

    def allinfos(self):
        return _solv.XRule_allinfos(self)

    def get_learnt(self):
        return _solv.XRule_get_learnt(self)

    def get_decisionlist(self):
        return _solv.XRule_get_decisionlist(self)

    def get_decisionsetlist(self):
        return _solv.XRule_get_decisionsetlist(self)

    def __eq__(self, xr):
        return _solv.XRule___eq__(self, xr)

    def __ne__(self, xr):
        return _solv.XRule___ne__(self, xr)

    def __hash__(self):
        return _solv.XRule___hash__(self)

    def __repr__(self):
        return _solv.XRule___repr__(self)
    __swig_destroy__ = _solv.delete_XRule

# Register XRule in _solv:
_solv.XRule_swigregister(XRule)
class XRepodata(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    repo = property(_solv.XRepodata_repo_get)
    id = property(_solv.XRepodata_id_get)

    def __init__(self, repo, id):
        _solv.XRepodata_swiginit(self, _solv.new_XRepodata(repo, id))

    def new_handle(self):
        return _solv.XRepodata_new_handle(self)

    def set_id(self, solvid, keyname, id):
        return _solv.XRepodata_set_id(self, solvid, keyname, id)

    def set_num(self, solvid, keyname, num):
        return _solv.XRepodata_set_num(self, solvid, keyname, num)

    def set_str(self, solvid, keyname, str):
        return _solv.XRepodata_set_str(self, solvid, keyname, str)

    def set_void(self, solvid, keyname):
        return _solv.XRepodata_set_void(self, solvid, keyname)

    def set_poolstr(self, solvid, keyname, str):
        return _solv.XRepodata_set_poolstr(self, solvid, keyname, str)

    def add_idarray(self, solvid, keyname, id):
        return _solv.XRepodata_add_idarray(self, solvid, keyname, id)

    def add_flexarray(self, solvid, keyname, handle):
        return _solv.XRepodata_add_flexarray(self, solvid, keyname, handle)

    def set_checksum(self, solvid, keyname, chksum):
        return _solv.XRepodata_set_checksum(self, solvid, keyname, chksum)

    def set_sourcepkg(self, solvid, sourcepkg):
        return _solv.XRepodata_set_sourcepkg(self, solvid, sourcepkg)

    def set_location(self, solvid, mediano, location):
        return _solv.XRepodata_set_location(self, solvid, mediano, location)

    def unset(self, solvid, keyname):
        return _solv.XRepodata_unset(self, solvid, keyname)

    def lookup_str(self, solvid, keyname):
        return _solv.XRepodata_lookup_str(self, solvid, keyname)

    def lookup_id(self, solvid, keyname):
        return _solv.XRepodata_lookup_id(self, solvid, keyname)

    def lookup_num(self, solvid, keyname, notfound=0):
        return _solv.XRepodata_lookup_num(self, solvid, keyname, notfound)

    def lookup_void(self, solvid, keyname):
        return _solv.XRepodata_lookup_void(self, solvid, keyname)

    def lookup_idarray(self, solvid, keyname):
        return _solv.XRepodata_lookup_idarray(self, solvid, keyname)

    def lookup_checksum(self, solvid, keyname):
        return _solv.XRepodata_lookup_checksum(self, solvid, keyname)

    def internalize(self):
        return _solv.XRepodata_internalize(self)

    def create_stubs(self):
        return _solv.XRepodata_create_stubs(self)

    def write(self, fp):
        return _solv.XRepodata_write(self, fp)

    def str2dir(self, dir, create=True):
        return _solv.XRepodata_str2dir(self, dir, create)

    def dir2str(self, did, suf=None):
        return _solv.XRepodata_dir2str(self, did, suf)

    def add_dirstr(self, solvid, keyname, dir, str):
        return _solv.XRepodata_add_dirstr(self, solvid, keyname, dir, str)

    def add_solv(self, fp, flags=0):
        return _solv.XRepodata_add_solv(self, fp, flags)

    def extend_to_repo(self):
        return _solv.XRepodata_extend_to_repo(self)

    def __eq__(self, xr):
        return _solv.XRepodata___eq__(self, xr)

    def __ne__(self, xr):
        return _solv.XRepodata___ne__(self, xr)

    def __hash__(self):
        return _solv.XRepodata___hash__(self)

    def __repr__(self):
        return _solv.XRepodata___repr__(self)
    __swig_destroy__ = _solv.delete_XRepodata

# Register XRepodata in _solv:
_solv.XRepodata_swigregister(XRepodata)
class Pool_solvable_iterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pool):
        _solv.Pool_solvable_iterator_swiginit(self, _solv.new_Pool_solvable_iterator(pool))

    def __iter__(self): return self


    def __next__(self):
        return _solv.Pool_solvable_iterator___next__(self)

    def __getitem__(self, key):
        return _solv.Pool_solvable_iterator___getitem__(self, key)

    def __len__(self):
        return _solv.Pool_solvable_iterator___len__(self)
    __swig_destroy__ = _solv.delete_Pool_solvable_iterator

# Register Pool_solvable_iterator in _solv:
_solv.Pool_solvable_iterator_swigregister(Pool_solvable_iterator)
class Pool_repo_iterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pool):
        _solv.Pool_repo_iterator_swiginit(self, _solv.new_Pool_repo_iterator(pool))

    def __iter__(self): return self


    def __next__(self):
        return _solv.Pool_repo_iterator___next__(self)

    def __getitem__(self, key):
        return _solv.Pool_repo_iterator___getitem__(self, key)

    def __len__(self):
        return _solv.Pool_repo_iterator___len__(self)
    __swig_destroy__ = _solv.delete_Pool_repo_iterator

# Register Pool_repo_iterator in _solv:
_solv.Pool_repo_iterator_swigregister(Pool_repo_iterator)
class Repo_solvable_iterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, repo):
        _solv.Repo_solvable_iterator_swiginit(self, _solv.new_Repo_solvable_iterator(repo))

    def __iter__(self): return self


    def __next__(self):
        return _solv.Repo_solvable_iterator___next__(self)

    def __getitem__(self, key):
        return _solv.Repo_solvable_iterator___getitem__(self, key)

    def __len__(self):
        return _solv.Repo_solvable_iterator___len__(self)
    __swig_destroy__ = _solv.delete_Repo_solvable_iterator

# Register Repo_solvable_iterator in _solv:
_solv.Repo_solvable_iterator_swigregister(Repo_solvable_iterator)
class Datamatch(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    pool = property(_solv.Datamatch_pool_get)
    repo = property(_solv.Datamatch_repo_get)
    solvid = property(_solv.Datamatch_solvid_get)
    __swig_destroy__ = _solv.delete_Datamatch
    solvable = property(_solv.Datamatch_solvable_get)
    key_id = property(_solv.Datamatch_key_id_get)
    key_idstr = property(_solv.Datamatch_key_idstr_get)
    type_id = property(_solv.Datamatch_type_id_get)
    type_idstr = property(_solv.Datamatch_type_idstr_get)
    id = property(_solv.Datamatch_id_get)
    idstr = property(_solv.Datamatch_idstr_get)
    str = property(_solv.Datamatch_str_get)
    dep = property(_solv.Datamatch_dep_get)
    binary = property(_solv.Datamatch_binary_get)
    num = property(_solv.Datamatch_num_get)
    num2 = property(_solv.Datamatch_num2_get)

    def pos(self):
        return _solv.Datamatch_pos(self)

    def parentpos(self):
        return _solv.Datamatch_parentpos(self)

    def __str__(self):
        return _solv.Datamatch___str__(self)

# Register Datamatch in _solv:
_solv.Datamatch_swigregister(Datamatch)
class Datapos(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    repo = property(_solv.Datapos_repo_get)

    def lookup_id(self, keyname):
        return _solv.Datapos_lookup_id(self, keyname)

    def lookup_str(self, keyname):
        return _solv.Datapos_lookup_str(self, keyname)

    def lookup_num(self, keyname, notfound=0):
        return _solv.Datapos_lookup_num(self, keyname, notfound)

    def lookup_void(self, keyname):
        return _solv.Datapos_lookup_void(self, keyname)

    def lookup_checksum(self, keyname):
        return _solv.Datapos_lookup_checksum(self, keyname)

    def lookup_deltaseq(self):
        return _solv.Datapos_lookup_deltaseq(self)

    def lookup_deltalocation(self):
        return _solv.Datapos_lookup_deltalocation(self)

    def lookup_idarray(self, keyname):
        return _solv.Datapos_lookup_idarray(self, keyname)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.Datapos_Dataiterator(self, key, match, flags)
    __swig_destroy__ = _solv.delete_Datapos

# Register Datapos in _solv:
_solv.Datapos_swigregister(Datapos)
class Job(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    pool = property(_solv.Job_pool_get)
    how = property(_solv.Job_how_get, _solv.Job_how_set)
    what = property(_solv.Job_what_get, _solv.Job_what_set)
    SOLVER_SOLVABLE = _solv.Job_SOLVER_SOLVABLE
    SOLVER_SOLVABLE_NAME = _solv.Job_SOLVER_SOLVABLE_NAME
    SOLVER_SOLVABLE_PROVIDES = _solv.Job_SOLVER_SOLVABLE_PROVIDES
    SOLVER_SOLVABLE_ONE_OF = _solv.Job_SOLVER_SOLVABLE_ONE_OF
    SOLVER_SOLVABLE_REPO = _solv.Job_SOLVER_SOLVABLE_REPO
    SOLVER_SOLVABLE_ALL = _solv.Job_SOLVER_SOLVABLE_ALL
    SOLVER_SELECTMASK = _solv.Job_SOLVER_SELECTMASK
    SOLVER_NOOP = _solv.Job_SOLVER_NOOP
    SOLVER_INSTALL = _solv.Job_SOLVER_INSTALL
    SOLVER_ERASE = _solv.Job_SOLVER_ERASE
    SOLVER_UPDATE = _solv.Job_SOLVER_UPDATE
    SOLVER_WEAKENDEPS = _solv.Job_SOLVER_WEAKENDEPS
    SOLVER_MULTIVERSION = _solv.Job_SOLVER_MULTIVERSION
    SOLVER_LOCK = _solv.Job_SOLVER_LOCK
    SOLVER_DISTUPGRADE = _solv.Job_SOLVER_DISTUPGRADE
    SOLVER_VERIFY = _solv.Job_SOLVER_VERIFY
    SOLVER_DROP_ORPHANED = _solv.Job_SOLVER_DROP_ORPHANED
    SOLVER_USERINSTALLED = _solv.Job_SOLVER_USERINSTALLED
    SOLVER_ALLOWUNINSTALL = _solv.Job_SOLVER_ALLOWUNINSTALL
    SOLVER_FAVOR = _solv.Job_SOLVER_FAVOR
    SOLVER_DISFAVOR = _solv.Job_SOLVER_DISFAVOR
    SOLVER_EXCLUDEFROMWEAK = _solv.Job_SOLVER_EXCLUDEFROMWEAK
    SOLVER_JOBMASK = _solv.Job_SOLVER_JOBMASK
    SOLVER_WEAK = _solv.Job_SOLVER_WEAK
    SOLVER_ESSENTIAL = _solv.Job_SOLVER_ESSENTIAL
    SOLVER_CLEANDEPS = _solv.Job_SOLVER_CLEANDEPS
    SOLVER_FORCEBEST = _solv.Job_SOLVER_FORCEBEST
    SOLVER_TARGETED = _solv.Job_SOLVER_TARGETED
    SOLVER_NOTBYUSER = _solv.Job_SOLVER_NOTBYUSER
    SOLVER_SETEV = _solv.Job_SOLVER_SETEV
    SOLVER_SETEVR = _solv.Job_SOLVER_SETEVR
    SOLVER_SETARCH = _solv.Job_SOLVER_SETARCH
    SOLVER_SETVENDOR = _solv.Job_SOLVER_SETVENDOR
    SOLVER_SETREPO = _solv.Job_SOLVER_SETREPO
    SOLVER_SETNAME = _solv.Job_SOLVER_SETNAME
    SOLVER_NOAUTOSET = _solv.Job_SOLVER_NOAUTOSET
    SOLVER_SETMASK = _solv.Job_SOLVER_SETMASK

    def __init__(self, pool, how, what):
        _solv.Job_swiginit(self, _solv.new_Job(pool, how, what))

    def solvables(self):
        return _solv.Job_solvables(self)

    def isemptyupdate(self):
        return _solv.Job_isemptyupdate(self)

    def __eq__(self, j):
        return _solv.Job___eq__(self, j)

    def __ne__(self, j):
        return _solv.Job___ne__(self, j)

    def __str__(self):
        return _solv.Job___str__(self)

    def __repr__(self):
        return _solv.Job___repr__(self)
    __swig_destroy__ = _solv.delete_Job

# Register Job in _solv:
_solv.Job_swigregister(Job)
class Pool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    POOL_FLAG_PROMOTEEPOCH = _solv.Pool_POOL_FLAG_PROMOTEEPOCH
    POOL_FLAG_FORBIDSELFCONFLICTS = _solv.Pool_POOL_FLAG_FORBIDSELFCONFLICTS
    POOL_FLAG_OBSOLETEUSESPROVIDES = _solv.Pool_POOL_FLAG_OBSOLETEUSESPROVIDES
    POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES = _solv.Pool_POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES
    POOL_FLAG_OBSOLETEUSESCOLORS = _solv.Pool_POOL_FLAG_OBSOLETEUSESCOLORS
    POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS = _solv.Pool_POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS
    POOL_FLAG_NOINSTALLEDOBSOLETES = _solv.Pool_POOL_FLAG_NOINSTALLEDOBSOLETES
    POOL_FLAG_HAVEDISTEPOCH = _solv.Pool_POOL_FLAG_HAVEDISTEPOCH
    POOL_FLAG_NOOBSOLETESMULTIVERSION = _solv.Pool_POOL_FLAG_NOOBSOLETESMULTIVERSION
    POOL_FLAG_ADDFILEPROVIDESFILTERED = _solv.Pool_POOL_FLAG_ADDFILEPROVIDESFILTERED
    POOL_FLAG_NOWHATPROVIDESAUX = _solv.Pool_POOL_FLAG_NOWHATPROVIDESAUX
    POOL_FLAG_WHATPROVIDESWITHDISABLED = _solv.Pool_POOL_FLAG_WHATPROVIDESWITHDISABLED
    DISTTYPE_RPM = _solv.Pool_DISTTYPE_RPM
    DISTTYPE_DEB = _solv.Pool_DISTTYPE_DEB
    DISTTYPE_ARCH = _solv.Pool_DISTTYPE_ARCH
    DISTTYPE_HAIKU = _solv.Pool_DISTTYPE_HAIKU
    DISTTYPE_CONDA = _solv.Pool_DISTTYPE_CONDA
    DISTTYPE_APK = _solv.Pool_DISTTYPE_APK

    def __init__(self):
        _solv.Pool_swiginit(self, _solv.new_Pool())

    def setdisttype(self, disttype):
        return _solv.Pool_setdisttype(self, disttype)

    def set_debuglevel(self, level):
        return _solv.Pool_set_debuglevel(self, level)

    def set_flag(self, flag, value):
        return _solv.Pool_set_flag(self, flag, value)

    def get_flag(self, flag):
        return _solv.Pool_get_flag(self, flag)

    def set_rootdir(self, rootdir):
        return _solv.Pool_set_rootdir(self, rootdir)

    def get_rootdir(self, flag):
        return _solv.Pool_get_rootdir(self, flag)

    def clr_loadcallback(self):
        return _solv.Pool_clr_loadcallback(self)

    def set_loadcallback(self, callable):
        return _solv.Pool_set_loadcallback(self, callable)
    __swig_destroy__ = _solv.delete_Pool

    def free(self):
        return _solv.Pool_free(self)

    def disown(self):
        return _solv.Pool_disown(self)
    appdata = property(_solv.Pool_appdata_get, _solv.Pool_appdata_set)

    def appdata_disown(self):
        return _solv.Pool_appdata_disown(self)

    def str2id(self, str, create=True):
        return _solv.Pool_str2id(self, str, create)

    def Dep(self, str, create=True):
        return _solv.Pool_Dep(self, str, create)

    def parserpmrichdep(self, str):
        return _solv.Pool_parserpmrichdep(self, str)

    def id2str(self, id):
        return _solv.Pool_id2str(self, id)

    def dep2str(self, id):
        return _solv.Pool_dep2str(self, id)

    def rel2id(self, name, evr, flags, create=True):
        return _solv.Pool_rel2id(self, name, evr, flags, create)

    def id2langid(self, id, lang, create=True):
        return _solv.Pool_id2langid(self, id, lang, create)

    def setarch(self, arch=None):
        return _solv.Pool_setarch(self, arch)

    def add_repo(self, name):
        return _solv.Pool_add_repo(self, name)

    def lookup_str(self, entry, keyname):
        return _solv.Pool_lookup_str(self, entry, keyname)

    def lookup_id(self, entry, keyname):
        return _solv.Pool_lookup_id(self, entry, keyname)

    def lookup_num(self, entry, keyname, notfound=0):
        return _solv.Pool_lookup_num(self, entry, keyname, notfound)

    def lookup_void(self, entry, keyname):
        return _solv.Pool_lookup_void(self, entry, keyname)

    def lookup_checksum(self, entry, keyname):
        return _solv.Pool_lookup_checksum(self, entry, keyname)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.Pool_Dataiterator(self, key, match, flags)

    def Dataiterator_solvid(self, p, key, match=None, flags=0):
        return _solv.Pool_Dataiterator_solvid(self, p, key, match, flags)

    def solvid2str(self, solvid):
        return _solv.Pool_solvid2str(self, solvid)

    def solvidset2str(self, q):
        return _solv.Pool_solvidset2str(self, q)

    def solvableset2str(self, solvables):
        return _solv.Pool_solvableset2str(self, solvables)

    def addfileprovides(self):
        return _solv.Pool_addfileprovides(self)

    def addfileprovides_queue(self):
        return _solv.Pool_addfileprovides_queue(self)

    def createwhatprovides(self):
        return _solv.Pool_createwhatprovides(self)

    def id2solvable(self, id):
        return _solv.Pool_id2solvable(self, id)
    solvables = property(_solv.Pool_solvables_get)

    def solvables_iter(self):
        return _solv.Pool_solvables_iter(self)

    def id2repo(self, id):
        return _solv.Pool_id2repo(self, id)
    repos = property(_solv.Pool_repos_get)

    def repos_iter(self):
        return _solv.Pool_repos_iter(self)
    installed = property(_solv.Pool_installed_get, _solv.Pool_installed_set)
    errstr = property(_solv.Pool_errstr_get)

    def matchprovidingids(self, match, flags):
        return _solv.Pool_matchprovidingids(self, match, flags)

    def Job(self, how, what):
        return _solv.Pool_Job(self, how, what)

    def whatprovides(self, dep):
        return _solv.Pool_whatprovides(self, dep)

    def best_solvables(self, solvables, flags=0):
        return _solv.Pool_best_solvables(self, solvables, flags)

    def towhatprovides(self, q):
        return _solv.Pool_towhatprovides(self, q)

    def set_namespaceproviders(self, ns, evr, value=True):
        return _solv.Pool_set_namespaceproviders(self, ns, evr, value)

    def flush_namespaceproviders(self, ns, evr):
        return _solv.Pool_flush_namespaceproviders(self, ns, evr)

    def whatcontainsdep(self, keyname, dep, marker=-1):
        return _solv.Pool_whatcontainsdep(self, keyname, dep, marker)

    def whatmatchesdep(self, keyname, dep, marker=-1):
        return _solv.Pool_whatmatchesdep(self, keyname, dep, marker)

    def whatmatchessolvable(self, keyname, pool_solvable, marker=-1):
        return _solv.Pool_whatmatchessolvable(self, keyname, pool_solvable, marker)

    def isknownarch(self, id):
        return _solv.Pool_isknownarch(self, id)

    def Solver(self):
        return _solv.Pool_Solver(self)

    def Selection(self):
        return _solv.Pool_Selection(self)

    def Selection_all(self, setflags=0):
        return _solv.Pool_Selection_all(self, setflags)

    def select(self, name, flags):
        return _solv.Pool_select(self, name, flags)

    def matchdeps(self, name, flags, keyname, marker=-1):
        return _solv.Pool_matchdeps(self, name, flags, keyname, marker)

    def matchdepid(self, dep, flags, keyname, marker=-1):
        return _solv.Pool_matchdepid(self, dep, flags, keyname, marker)

    def matchsolvable(self, solvable, flags, keyname, marker=-1):
        return _solv.Pool_matchsolvable(self, solvable, flags, keyname, marker)

    def get_considered_list(self):
        return _solv.Pool_get_considered_list(self)

    def get_disabled_list(self):
        return _solv.Pool_get_disabled_list(self)

    def set_considered_list(self, q):
        return _solv.Pool_set_considered_list(self, q)

    def set_disabled_list(self, q):
        return _solv.Pool_set_disabled_list(self, q)

    def setpooljobs(self, solvejobs):
        return _solv.Pool_setpooljobs(self, solvejobs)

    def getpooljobs(self):
        return _solv.Pool_getpooljobs(self)

# Register Pool in _solv:
_solv.Pool_swigregister(Pool)
class Repo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    pool = property(_solv.Repo_pool_get)
    name = property(_solv.Repo_name_get)
    priority = property(_solv.Repo_priority_get, _solv.Repo_priority_set)
    subpriority = property(_solv.Repo_subpriority_get, _solv.Repo_subpriority_set)
    nsolvables = property(_solv.Repo_nsolvables_get)
    REPO_REUSE_REPODATA = _solv.Repo_REPO_REUSE_REPODATA
    REPO_NO_INTERNALIZE = _solv.Repo_REPO_NO_INTERNALIZE
    REPO_LOCALPOOL = _solv.Repo_REPO_LOCALPOOL
    REPO_USE_LOADING = _solv.Repo_REPO_USE_LOADING
    REPO_EXTEND_SOLVABLES = _solv.Repo_REPO_EXTEND_SOLVABLES
    REPO_USE_ROOTDIR = _solv.Repo_REPO_USE_ROOTDIR
    REPO_NO_LOCATION = _solv.Repo_REPO_NO_LOCATION
    SOLV_ADD_NO_STUBS = _solv.Repo_SOLV_ADD_NO_STUBS
    SUSETAGS_RECORD_SHARES = _solv.Repo_SUSETAGS_RECORD_SHARES

    def free(self, reuseids=False):
        return _solv.Repo_free(self, reuseids)

    def empty(self, reuseids=False):
        return _solv.Repo_empty(self, reuseids)

    def isempty(self):
        return _solv.Repo_isempty(self)
    appdata = property(_solv.Repo_appdata_get, _solv.Repo_appdata_set)

    def add_solv(self, *args):
        return _solv.Repo_add_solv(self, *args)

    def add_solvable(self):
        return _solv.Repo_add_solvable(self)

    def add_rpmdb(self, flags=0):
        return _solv.Repo_add_rpmdb(self, flags)

    def add_rpmdb_reffp(self, reffp, flags=0):
        return _solv.Repo_add_rpmdb_reffp(self, reffp, flags)

    def add_rpm(self, name, flags=0):
        return _solv.Repo_add_rpm(self, name, flags)

    def add_rpmdb_pubkeys(self, flags=0):
        return _solv.Repo_add_rpmdb_pubkeys(self, flags)

    def add_pubkey(self, keyfile, flags=0):
        return _solv.Repo_add_pubkey(self, keyfile, flags)

    def add_keyring(self, fp, flags=0):
        return _solv.Repo_add_keyring(self, fp, flags)

    def add_keydir(self, keydir, suffix, flags=0):
        return _solv.Repo_add_keydir(self, keydir, suffix, flags)

    def add_rpmmd(self, fp, language, flags=0):
        return _solv.Repo_add_rpmmd(self, fp, language, flags)

    def add_repomdxml(self, fp, flags=0):
        return _solv.Repo_add_repomdxml(self, fp, flags)

    def add_updateinfoxml(self, fp, flags=0):
        return _solv.Repo_add_updateinfoxml(self, fp, flags)

    def add_deltainfoxml(self, fp, flags=0):
        return _solv.Repo_add_deltainfoxml(self, fp, flags)

    def add_debdb(self, flags=0):
        return _solv.Repo_add_debdb(self, flags)

    def add_debpackages(self, fp, flags=0):
        return _solv.Repo_add_debpackages(self, fp, flags)

    def add_deb(self, name, flags=0):
        return _solv.Repo_add_deb(self, name, flags)

    def add_susetags(self, fp, defvendor, language, flags=0):
        return _solv.Repo_add_susetags(self, fp, defvendor, language, flags)

    def add_content(self, fp, flags=0):
        return _solv.Repo_add_content(self, fp, flags)

    def add_products(self, proddir, flags=0):
        return _solv.Repo_add_products(self, proddir, flags)

    def add_mdk(self, fp, flags=0):
        return _solv.Repo_add_mdk(self, fp, flags)

    def add_mdk_info(self, fp, flags=0):
        return _solv.Repo_add_mdk_info(self, fp, flags)

    def add_arch_repo(self, fp, flags=0):
        return _solv.Repo_add_arch_repo(self, fp, flags)

    def add_arch_local(self, dir, flags=0):
        return _solv.Repo_add_arch_local(self, dir, flags)

    def add_arch_pkg(self, name, flags=0):
        return _solv.Repo_add_arch_pkg(self, name, flags)

    def internalize(self):
        return _solv.Repo_internalize(self)

    def write(self, fp):
        return _solv.Repo_write(self, fp)

    def write_first_repodata(self, fp):
        return _solv.Repo_write_first_repodata(self, fp)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.Repo_Dataiterator(self, key, match, flags)

    def Dataiterator_meta(self, key, match=None, flags=0):
        return _solv.Repo_Dataiterator_meta(self, key, match, flags)
    id = property(_solv.Repo_id_get)
    solvables = property(_solv.Repo_solvables_get)
    meta = property(_solv.Repo_meta_get)

    def solvables_iter(self):
        return _solv.Repo_solvables_iter(self)

    def add_repodata(self, flags=0):
        return _solv.Repo_add_repodata(self, flags)

    def create_stubs(self):
        return _solv.Repo_create_stubs(self)

    def iscontiguous(self):
        return _solv.Repo_iscontiguous(self)

    def first_repodata(self):
        return _solv.Repo_first_repodata(self)

    def Selection(self, setflags=0):
        return _solv.Repo_Selection(self, setflags)

    def find_pubkey(self, keyid):
        return _solv.Repo_find_pubkey(self, keyid)

    def createshadow(self, name):
        return _solv.Repo_createshadow(self, name)

    def moveshadow(self, q):
        return _solv.Repo_moveshadow(self, q)

    def __eq__(self, repo):
        return _solv.Repo___eq__(self, repo)

    def __ne__(self, repo):
        return _solv.Repo___ne__(self, repo)

    def __hash__(self):
        return _solv.Repo___hash__(self)

    def __str__(self):
        return _solv.Repo___str__(self)

    def __repr__(self):
        return _solv.Repo___repr__(self)

# Register Repo in _solv:
_solv.Repo_swigregister(Repo)
class Decision(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    solv = property(_solv.Decision_solv_get)
    p = property(_solv.Decision_p_get)
    reason = property(_solv.Decision_reason_get)
    infoid = property(_solv.Decision_infoid_get)

    def __init__(self, solv, p, reason, infoid):
        _solv.Decision_swiginit(self, _solv.new_Decision(solv, p, reason, infoid))
    rule = property(_solv.Decision_rule_get)
    solvable = property(_solv.Decision_solvable_get)

    def info(self):
        return _solv.Decision_info(self)

    def allinfos(self):
        return _solv.Decision_allinfos(self)

    def reasonstr(self, noinfo=False):
        return _solv.Decision_reasonstr(self, noinfo)

    def __str__(self):
        return _solv.Decision___str__(self)
    __swig_destroy__ = _solv.delete_Decision

# Register Decision in _solv:
_solv.Decision_swigregister(Decision)
class Decisionset(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    solv = property(_solv.Decisionset_solv_get)
    p = property(_solv.Decisionset_p_get)
    reason = property(_solv.Decisionset_reason_get)
    infoid = property(_solv.Decisionset_infoid_get)
    bits = property(_solv.Decisionset_bits_get)
    type = property(_solv.Decisionset_type_get)
    dep_id = property(_solv.Decisionset_dep_id_get)

    def __init__(self, solv):
        _solv.Decisionset_swiginit(self, _solv.new_Decisionset(solv))
    __swig_destroy__ = _solv.delete_Decisionset

    def info(self):
        return _solv.Decisionset_info(self)
    dep = property(_solv.Decisionset_dep_get)

    def solvables(self):
        return _solv.Decisionset_solvables(self)

    def decisions(self):
        return _solv.Decisionset_decisions(self)

    def reasonstr(self, noinfo=False):
        return _solv.Decisionset_reasonstr(self, noinfo)

    def __str__(self):
        return _solv.Decisionset___str__(self)

# Register Decisionset in _solv:
_solv.Decisionset_swigregister(Decisionset)
class Solver(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    pool = property(_solv.Solver_pool_get)
    SOLVER_RULE_UNKNOWN = _solv.Solver_SOLVER_RULE_UNKNOWN
    SOLVER_RULE_PKG = _solv.Solver_SOLVER_RULE_PKG
    SOLVER_RULE_PKG_NOT_INSTALLABLE = _solv.Solver_SOLVER_RULE_PKG_NOT_INSTALLABLE
    SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP = _solv.Solver_SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP
    SOLVER_RULE_PKG_REQUIRES = _solv.Solver_SOLVER_RULE_PKG_REQUIRES
    SOLVER_RULE_PKG_SELF_CONFLICT = _solv.Solver_SOLVER_RULE_PKG_SELF_CONFLICT
    SOLVER_RULE_PKG_CONFLICTS = _solv.Solver_SOLVER_RULE_PKG_CONFLICTS
    SOLVER_RULE_PKG_SAME_NAME = _solv.Solver_SOLVER_RULE_PKG_SAME_NAME
    SOLVER_RULE_PKG_OBSOLETES = _solv.Solver_SOLVER_RULE_PKG_OBSOLETES
    SOLVER_RULE_PKG_IMPLICIT_OBSOLETES = _solv.Solver_SOLVER_RULE_PKG_IMPLICIT_OBSOLETES
    SOLVER_RULE_PKG_INSTALLED_OBSOLETES = _solv.Solver_SOLVER_RULE_PKG_INSTALLED_OBSOLETES
    SOLVER_RULE_PKG_RECOMMENDS = _solv.Solver_SOLVER_RULE_PKG_RECOMMENDS
    SOLVER_RULE_PKG_CONSTRAINS = _solv.Solver_SOLVER_RULE_PKG_CONSTRAINS
    SOLVER_RULE_PKG_SUPPLEMENTS = _solv.Solver_SOLVER_RULE_PKG_SUPPLEMENTS
    SOLVER_RULE_UPDATE = _solv.Solver_SOLVER_RULE_UPDATE
    SOLVER_RULE_FEATURE = _solv.Solver_SOLVER_RULE_FEATURE
    SOLVER_RULE_JOB = _solv.Solver_SOLVER_RULE_JOB
    SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = _solv.Solver_SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP
    SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM = _solv.Solver_SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM
    SOLVER_RULE_JOB_UNKNOWN_PACKAGE = _solv.Solver_SOLVER_RULE_JOB_UNKNOWN_PACKAGE
    SOLVER_RULE_JOB_UNSUPPORTED = _solv.Solver_SOLVER_RULE_JOB_UNSUPPORTED
    SOLVER_RULE_DISTUPGRADE = _solv.Solver_SOLVER_RULE_DISTUPGRADE
    SOLVER_RULE_INFARCH = _solv.Solver_SOLVER_RULE_INFARCH
    SOLVER_RULE_CHOICE = _solv.Solver_SOLVER_RULE_CHOICE
    SOLVER_RULE_LEARNT = _solv.Solver_SOLVER_RULE_LEARNT
    SOLVER_RULE_BEST = _solv.Solver_SOLVER_RULE_BEST
    SOLVER_RULE_YUMOBS = _solv.Solver_SOLVER_RULE_YUMOBS
    SOLVER_RULE_RECOMMENDS = _solv.Solver_SOLVER_RULE_RECOMMENDS
    SOLVER_RULE_BLACK = _solv.Solver_SOLVER_RULE_BLACK
    SOLVER_RULE_STRICT_REPO_PRIORITY = _solv.Solver_SOLVER_RULE_STRICT_REPO_PRIORITY
    SOLVER_SOLUTION_JOB = _solv.Solver_SOLVER_SOLUTION_JOB
    SOLVER_SOLUTION_POOLJOB = _solv.Solver_SOLVER_SOLUTION_POOLJOB
    SOLVER_SOLUTION_INFARCH = _solv.Solver_SOLVER_SOLUTION_INFARCH
    SOLVER_SOLUTION_DISTUPGRADE = _solv.Solver_SOLVER_SOLUTION_DISTUPGRADE
    SOLVER_SOLUTION_BEST = _solv.Solver_SOLVER_SOLUTION_BEST
    SOLVER_SOLUTION_ERASE = _solv.Solver_SOLVER_SOLUTION_ERASE
    SOLVER_SOLUTION_REPLACE = _solv.Solver_SOLVER_SOLUTION_REPLACE
    SOLVER_SOLUTION_REPLACE_DOWNGRADE = _solv.Solver_SOLVER_SOLUTION_REPLACE_DOWNGRADE
    SOLVER_SOLUTION_REPLACE_ARCHCHANGE = _solv.Solver_SOLVER_SOLUTION_REPLACE_ARCHCHANGE
    SOLVER_SOLUTION_REPLACE_VENDORCHANGE = _solv.Solver_SOLVER_SOLUTION_REPLACE_VENDORCHANGE
    SOLVER_SOLUTION_REPLACE_NAMECHANGE = _solv.Solver_SOLVER_SOLUTION_REPLACE_NAMECHANGE
    POLICY_ILLEGAL_DOWNGRADE = _solv.Solver_POLICY_ILLEGAL_DOWNGRADE
    POLICY_ILLEGAL_ARCHCHANGE = _solv.Solver_POLICY_ILLEGAL_ARCHCHANGE
    POLICY_ILLEGAL_VENDORCHANGE = _solv.Solver_POLICY_ILLEGAL_VENDORCHANGE
    POLICY_ILLEGAL_NAMECHANGE = _solv.Solver_POLICY_ILLEGAL_NAMECHANGE
    SOLVER_FLAG_ALLOW_DOWNGRADE = _solv.Solver_SOLVER_FLAG_ALLOW_DOWNGRADE
    SOLVER_FLAG_ALLOW_ARCHCHANGE = _solv.Solver_SOLVER_FLAG_ALLOW_ARCHCHANGE
    SOLVER_FLAG_ALLOW_VENDORCHANGE = _solv.Solver_SOLVER_FLAG_ALLOW_VENDORCHANGE
    SOLVER_FLAG_ALLOW_NAMECHANGE = _solv.Solver_SOLVER_FLAG_ALLOW_NAMECHANGE
    SOLVER_FLAG_ALLOW_UNINSTALL = _solv.Solver_SOLVER_FLAG_ALLOW_UNINSTALL
    SOLVER_FLAG_NO_UPDATEPROVIDE = _solv.Solver_SOLVER_FLAG_NO_UPDATEPROVIDE
    SOLVER_FLAG_SPLITPROVIDES = _solv.Solver_SOLVER_FLAG_SPLITPROVIDES
    SOLVER_FLAG_IGNORE_RECOMMENDED = _solv.Solver_SOLVER_FLAG_IGNORE_RECOMMENDED
    SOLVER_FLAG_ADD_ALREADY_RECOMMENDED = _solv.Solver_SOLVER_FLAG_ADD_ALREADY_RECOMMENDED
    SOLVER_FLAG_NO_INFARCHCHECK = _solv.Solver_SOLVER_FLAG_NO_INFARCHCHECK
    SOLVER_FLAG_BEST_OBEY_POLICY = _solv.Solver_SOLVER_FLAG_BEST_OBEY_POLICY
    SOLVER_FLAG_NO_AUTOTARGET = _solv.Solver_SOLVER_FLAG_NO_AUTOTARGET
    SOLVER_FLAG_DUP_ALLOW_DOWNGRADE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_DOWNGRADE
    SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE
    SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE
    SOLVER_FLAG_DUP_ALLOW_NAMECHANGE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_NAMECHANGE
    SOLVER_FLAG_KEEP_ORPHANS = _solv.Solver_SOLVER_FLAG_KEEP_ORPHANS
    SOLVER_FLAG_BREAK_ORPHANS = _solv.Solver_SOLVER_FLAG_BREAK_ORPHANS
    SOLVER_FLAG_FOCUS_INSTALLED = _solv.Solver_SOLVER_FLAG_FOCUS_INSTALLED
    SOLVER_FLAG_YUM_OBSOLETES = _solv.Solver_SOLVER_FLAG_YUM_OBSOLETES
    SOLVER_FLAG_NEED_UPDATEPROVIDE = _solv.Solver_SOLVER_FLAG_NEED_UPDATEPROVIDE
    SOLVER_FLAG_FOCUS_BEST = _solv.Solver_SOLVER_FLAG_FOCUS_BEST
    SOLVER_FLAG_STRONG_RECOMMENDS = _solv.Solver_SOLVER_FLAG_STRONG_RECOMMENDS
    SOLVER_FLAG_INSTALL_ALSO_UPDATES = _solv.Solver_SOLVER_FLAG_INSTALL_ALSO_UPDATES
    SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED = _solv.Solver_SOLVER_FLAG_ONLY_NAMESPACE_RECOMMENDED
    SOLVER_FLAG_STRICT_REPO_PRIORITY = _solv.Solver_SOLVER_FLAG_STRICT_REPO_PRIORITY
    SOLVER_FLAG_FOCUS_NEW = _solv.Solver_SOLVER_FLAG_FOCUS_NEW
    SOLVER_REASON_UNRELATED = _solv.Solver_SOLVER_REASON_UNRELATED
    SOLVER_REASON_UNIT_RULE = _solv.Solver_SOLVER_REASON_UNIT_RULE
    SOLVER_REASON_KEEP_INSTALLED = _solv.Solver_SOLVER_REASON_KEEP_INSTALLED
    SOLVER_REASON_RESOLVE_JOB = _solv.Solver_SOLVER_REASON_RESOLVE_JOB
    SOLVER_REASON_UPDATE_INSTALLED = _solv.Solver_SOLVER_REASON_UPDATE_INSTALLED
    SOLVER_REASON_CLEANDEPS_ERASE = _solv.Solver_SOLVER_REASON_CLEANDEPS_ERASE
    SOLVER_REASON_RESOLVE = _solv.Solver_SOLVER_REASON_RESOLVE
    SOLVER_REASON_WEAKDEP = _solv.Solver_SOLVER_REASON_WEAKDEP
    SOLVER_REASON_RESOLVE_ORPHAN = _solv.Solver_SOLVER_REASON_RESOLVE_ORPHAN
    SOLVER_REASON_RECOMMENDED = _solv.Solver_SOLVER_REASON_RECOMMENDED
    SOLVER_REASON_SUPPLEMENTED = _solv.Solver_SOLVER_REASON_SUPPLEMENTED
    SOLVER_REASON_UNSOLVABLE = _solv.Solver_SOLVER_REASON_UNSOLVABLE
    SOLVER_REASON_PREMISE = _solv.Solver_SOLVER_REASON_PREMISE
    SOLVER_RULE_RPM = _solv.Solver_SOLVER_RULE_RPM
    __swig_destroy__ = _solv.delete_Solver

    def set_flag(self, flag, value):
        return _solv.Solver_set_flag(self, flag, value)

    def get_flag(self, flag):
        return _solv.Solver_get_flag(self, flag)

    def solve(self, solvejobs):
        return _solv.Solver_solve(self, solvejobs)

    def transaction(self):
        return _solv.Solver_transaction(self)

    def describe_decision(self, s):
        return _solv.Solver_describe_decision(self, s)

    def describe_weakdep_decision_raw(self, s):
        return _solv.Solver_describe_weakdep_decision_raw(self, s)

    def describe_weakdep_decision(self, s):
      d = iter(self.describe_weakdep_decision_raw(s))
      return [ (t, XSolvable(self.pool, sid), Dep(self.pool, id)) for t, sid, id in zip(d, d, d) ]


    def alternatives_count(self):
        return _solv.Solver_alternatives_count(self)

    def get_alternative(self, aid):
        return _solv.Solver_get_alternative(self, aid)

    def alternatives(self):
        return _solv.Solver_alternatives(self)

    def write_testcase(self, dir):
        return _solv.Solver_write_testcase(self, dir)

    def raw_decisions(self, filter=0):
        return _solv.Solver_raw_decisions(self, filter)

    def all_decisions(self, filter=0):
        return _solv.Solver_all_decisions(self, filter)

    def get_decision(self, s):
        return _solv.Solver_get_decision(self, s)

    def get_learnt(self, s):
        return _solv.Solver_get_learnt(self, s)

    def get_decisionlist(self, s):
        return _solv.Solver_get_decisionlist(self, s)

    def get_recommended(self, noselected=False):
        return _solv.Solver_get_recommended(self, noselected)

    def get_suggested(self, noselected=False):
        return _solv.Solver_get_suggested(self, noselected)

# Register Solver in _solv:
_solv.Solver_swigregister(Solver)
class Chksum(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        _solv.Chksum_swiginit(self, _solv.new_Chksum(*args))

    @staticmethod
    def from_bin(type, str):
        return _solv.Chksum_from_bin(type, str)
    __swig_destroy__ = _solv.delete_Chksum
    type = property(_solv.Chksum_type_get)

    def add(self, str):
        return _solv.Chksum_add(self, str)

    def add_fp(self, fp):
        return _solv.Chksum_add_fp(self, fp)

    def add_fd(self, fd):
        return _solv.Chksum_add_fd(self, fd)

    def add_stat(self, filename):
        return _solv.Chksum_add_stat(self, filename)

    def add_fstat(self, fd):
        return _solv.Chksum_add_fstat(self, fd)

    def raw(self):
        return _solv.Chksum_raw(self)

    def hex(self):
        return _solv.Chksum_hex(self)

    def typestr(self):
        return _solv.Chksum_typestr(self)

    def __eq__(self, chk):
        return _solv.Chksum___eq__(self, chk)

    def __ne__(self, chk):
        return _solv.Chksum___ne__(self, chk)

    def __str__(self):
        return _solv.Chksum___str__(self)

    def __repr__(self):
        return _solv.Chksum___repr__(self)

# Register Chksum in _solv:
_solv.Chksum_swigregister(Chksum)
class Solvsig(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    htype = property(_solv.Solvsig_htype_get)
    created = property(_solv.Solvsig_created_get)
    expires = property(_solv.Solvsig_expires_get)
    keyid = property(_solv.Solvsig_keyid_get)

    def __init__(self, fp):
        _solv.Solvsig_swiginit(self, _solv.new_Solvsig(fp))
    __swig_destroy__ = _solv.delete_Solvsig

    def Chksum(self):
        return _solv.Solvsig_Chksum(self)

    def verify(self, repo, chksum):
        return _solv.Solvsig_verify(self, repo, chksum)

# Register Solvsig in _solv:
_solv.Solvsig_swigregister(Solvsig)
class SolvFp(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _solv.delete_SolvFp

    def fileno(self):
        return _solv.SolvFp_fileno(self)

    def dup(self):
        return _solv.SolvFp_dup(self)

    def write(self, str):
        return _solv.SolvFp_write(self, str)

    def flush(self):
        return _solv.SolvFp_flush(self)

    def close(self):
        return _solv.SolvFp_close(self)

    def cloexec(self, state):
        return _solv.SolvFp_cloexec(self, state)

# Register SolvFp in _solv:
_solv.SolvFp_swigregister(SolvFp)

def xfopen(fn, mode=None):
    return _solv.xfopen(fn, mode)

def xfopen_fd(fn, fd, mode=None):
    return _solv.xfopen_fd(fn, fd, mode)
class Problem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    solv = property(_solv.Problem_solv_get)
    id = property(_solv.Problem_id_get)

    def __init__(self, solv, id):
        _solv.Problem_swiginit(self, _solv.new_Problem(solv, id))

    def findproblemrule(self):
        return _solv.Problem_findproblemrule(self)

    def findallproblemrules(self, unfiltered=0):
        return _solv.Problem_findallproblemrules(self, unfiltered)

    def solution_count(self):
        return _solv.Problem_solution_count(self)

    def solutions(self):
        return _solv.Problem_solutions(self)

    def get_learnt(self):
        return _solv.Problem_get_learnt(self)

    def get_decisionlist(self):
        return _solv.Problem_get_decisionlist(self)

    def get_decisionsetlist(self):
        return _solv.Problem_get_decisionsetlist(self)

    def __str__(self):
        return _solv.Problem___str__(self)
    __swig_destroy__ = _solv.delete_Problem

# Register Problem in _solv:
_solv.Problem_swigregister(Problem)
class Solution(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    solv = property(_solv.Solution_solv_get)
    problemid = property(_solv.Solution_problemid_get)
    id = property(_solv.Solution_id_get)

    def __init__(self, p, id):
        _solv.Solution_swiginit(self, _solv.new_Solution(p, id))

    def element_count(self):
        return _solv.Solution_element_count(self)

    def elements(self, expandreplaces=False):
        return _solv.Solution_elements(self, expandreplaces)
    __swig_destroy__ = _solv.delete_Solution

# Register Solution in _solv:
_solv.Solution_swigregister(Solution)
class Solutionelement(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    solv = property(_solv.Solutionelement_solv_get)
    problemid = property(_solv.Solutionelement_problemid_get)
    solutionid = property(_solv.Solutionelement_solutionid_get)
    type = property(_solv.Solutionelement_type_get)

    def __init__(self, solv, problemid, solutionid, type, p, rp):
        _solv.Solutionelement_swiginit(self, _solv.new_Solutionelement(solv, problemid, solutionid, type, p, rp))

    def str(self):
        return _solv.Solutionelement_str(self)

    def __str__(self):
        return _solv.Solutionelement___str__(self)

    def replaceelements(self):
        return _solv.Solutionelement_replaceelements(self)

    def illegalreplace(self):
        return _solv.Solutionelement_illegalreplace(self)
    solvable = property(_solv.Solutionelement_solvable_get)
    replacement = property(_solv.Solutionelement_replacement_get)
    jobidx = property(_solv.Solutionelement_jobidx_get)

    def Job(self):
        return _solv.Solutionelement_Job(self)
    __swig_destroy__ = _solv.delete_Solutionelement

# Register Solutionelement in _solv:
_solv.Solutionelement_swigregister(Solutionelement)
class Alternative(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    solv = property(_solv.Alternative_solv_get)
    type = property(_solv.Alternative_type_get)
    dep_id = property(_solv.Alternative_dep_id_get)
    chosen_id = property(_solv.Alternative_chosen_id_get)
    level = property(_solv.Alternative_level_get)
    SOLVER_ALTERNATIVE_TYPE_RULE = _solv.Alternative_SOLVER_ALTERNATIVE_TYPE_RULE
    SOLVER_ALTERNATIVE_TYPE_RECOMMENDS = _solv.Alternative_SOLVER_ALTERNATIVE_TYPE_RECOMMENDS
    SOLVER_ALTERNATIVE_TYPE_SUGGESTS = _solv.Alternative_SOLVER_ALTERNATIVE_TYPE_SUGGESTS
    __swig_destroy__ = _solv.delete_Alternative
    chosen = property(_solv.Alternative_chosen_get)
    rule = property(_solv.Alternative_rule_get)
    depsolvable = property(_solv.Alternative_depsolvable_get)
    dep = property(_solv.Alternative_dep_get)

    def choices_raw(self):
        return _solv.Alternative_choices_raw(self)

    def choices(self):
        return _solv.Alternative_choices(self)

    def __str__(self):
        return _solv.Alternative___str__(self)

# Register Alternative in _solv:
_solv.Alternative_swigregister(Alternative)
class Transaction(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    pool = property(_solv.Transaction_pool_get)
    SOLVER_TRANSACTION_IGNORE = _solv.Transaction_SOLVER_TRANSACTION_IGNORE
    SOLVER_TRANSACTION_ERASE = _solv.Transaction_SOLVER_TRANSACTION_ERASE
    SOLVER_TRANSACTION_REINSTALLED = _solv.Transaction_SOLVER_TRANSACTION_REINSTALLED
    SOLVER_TRANSACTION_DOWNGRADED = _solv.Transaction_SOLVER_TRANSACTION_DOWNGRADED
    SOLVER_TRANSACTION_CHANGED = _solv.Transaction_SOLVER_TRANSACTION_CHANGED
    SOLVER_TRANSACTION_UPGRADED = _solv.Transaction_SOLVER_TRANSACTION_UPGRADED
    SOLVER_TRANSACTION_OBSOLETED = _solv.Transaction_SOLVER_TRANSACTION_OBSOLETED
    SOLVER_TRANSACTION_INSTALL = _solv.Transaction_SOLVER_TRANSACTION_INSTALL
    SOLVER_TRANSACTION_REINSTALL = _solv.Transaction_SOLVER_TRANSACTION_REINSTALL
    SOLVER_TRANSACTION_DOWNGRADE = _solv.Transaction_SOLVER_TRANSACTION_DOWNGRADE
    SOLVER_TRANSACTION_CHANGE = _solv.Transaction_SOLVER_TRANSACTION_CHANGE
    SOLVER_TRANSACTION_UPGRADE = _solv.Transaction_SOLVER_TRANSACTION_UPGRADE
    SOLVER_TRANSACTION_OBSOLETES = _solv.Transaction_SOLVER_TRANSACTION_OBSOLETES
    SOLVER_TRANSACTION_MULTIINSTALL = _solv.Transaction_SOLVER_TRANSACTION_MULTIINSTALL
    SOLVER_TRANSACTION_MULTIREINSTALL = _solv.Transaction_SOLVER_TRANSACTION_MULTIREINSTALL
    SOLVER_TRANSACTION_MAXTYPE = _solv.Transaction_SOLVER_TRANSACTION_MAXTYPE
    SOLVER_TRANSACTION_SHOW_ACTIVE = _solv.Transaction_SOLVER_TRANSACTION_SHOW_ACTIVE
    SOLVER_TRANSACTION_SHOW_ALL = _solv.Transaction_SOLVER_TRANSACTION_SHOW_ALL
    SOLVER_TRANSACTION_SHOW_OBSOLETES = _solv.Transaction_SOLVER_TRANSACTION_SHOW_OBSOLETES
    SOLVER_TRANSACTION_SHOW_MULTIINSTALL = _solv.Transaction_SOLVER_TRANSACTION_SHOW_MULTIINSTALL
    SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = _solv.Transaction_SOLVER_TRANSACTION_CHANGE_IS_REINSTALL
    SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE = _solv.Transaction_SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE
    SOLVER_TRANSACTION_MERGE_VENDORCHANGES = _solv.Transaction_SOLVER_TRANSACTION_MERGE_VENDORCHANGES
    SOLVER_TRANSACTION_MERGE_ARCHCHANGES = _solv.Transaction_SOLVER_TRANSACTION_MERGE_ARCHCHANGES
    SOLVER_TRANSACTION_RPM_ONLY = _solv.Transaction_SOLVER_TRANSACTION_RPM_ONLY
    SOLVER_TRANSACTION_ARCHCHANGE = _solv.Transaction_SOLVER_TRANSACTION_ARCHCHANGE
    SOLVER_TRANSACTION_VENDORCHANGE = _solv.Transaction_SOLVER_TRANSACTION_VENDORCHANGE
    SOLVER_TRANSACTION_KEEP_ORDERDATA = _solv.Transaction_SOLVER_TRANSACTION_KEEP_ORDERDATA
    __swig_destroy__ = _solv.delete_Transaction

    def isempty(self):
        return _solv.Transaction_isempty(self)

    def othersolvable(self, s):
        return _solv.Transaction_othersolvable(self, s)

    def allothersolvables(self, s):
        return _solv.Transaction_allothersolvables(self, s)

    def classify(self, mode=0):
        return _solv.Transaction_classify(self, mode)

    def newpackages(self):
        return _solv.Transaction_newpackages(self)

    def keptpackages(self):
        return _solv.Transaction_keptpackages(self)

    def newsolvables(self):
        return _solv.Transaction_newsolvables(self)

    def keptsolvables(self):
        return _solv.Transaction_keptsolvables(self)

    def steps(self):
        return _solv.Transaction_steps(self)

    def steptype(self, s, mode):
        return _solv.Transaction_steptype(self, s, mode)

    def calc_installsizechange(self):
        return _solv.Transaction_calc_installsizechange(self)

    def order(self, flags=0):
        return _solv.Transaction_order(self, flags)

# Register Transaction in _solv:
_solv.Transaction_swigregister(Transaction)
class TransactionClass(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    transaction = property(_solv.TransactionClass_transaction_get)
    type = property(_solv.TransactionClass_type_get)
    fromid = property(_solv.TransactionClass_fromid_get)
    toid = property(_solv.TransactionClass_toid_get)
    count = property(_solv.TransactionClass_count_get)

    def __init__(self, trans, mode, type, count, fromid, toid):
        _solv.TransactionClass_swiginit(self, _solv.new_TransactionClass(trans, mode, type, count, fromid, toid))

    def solvables(self):
        return _solv.TransactionClass_solvables(self)
    fromstr = property(_solv.TransactionClass_fromstr_get)
    tostr = property(_solv.TransactionClass_tostr_get)
    __swig_destroy__ = _solv.delete_TransactionClass

# Register TransactionClass in _solv:
_solv.TransactionClass_swigregister(TransactionClass)

