# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.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 __package__ or "." in __name__:
    from . import _manifest
else:
    import _manifest

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__)



def add_property_accessors(target_cls, src_cls=None, src_getter=None):
    """
    Dynamically creates attributes in the target class based on the getter and setter
    methods of a source class.

    This method inspects the source class for methods with 'get_' and 'set_' prefixes,
    and creates corresponding properties in the target class. If a `src_getter` is provided,
    it is used to obtain an instance of the source class, allowing for delegation of property
    access.

    Args:
        target_cls (type): The class where the properties will be added.
        src_cls (type, optional): The class to inspect for getter and setter methods.
                                  If not provided, the target class is used.
        src_getter (callable, optional): A callable that takes an instance of the target class
                                          and returns an instance of the source class.
                                          This is used for delegating property access.

    Example:
        1. Simplifying Access in the Package Class
        - Before: package.get_size()
        - After calling add_property_accessors(Package): package.size

        2. Delegating Access of Internal Objects
        - Before: package.get_nevra().get_name()
        - After calling add_property_accessors(Package, Nevra, Package.get_nevra): package.name
    """
    def create_getter(getter_name):
        def getter(self):
            getter_target = src_getter(self) if src_getter else self
            return getattr(getter_target, getter_name)() if getter_name in dir(getter_target) else None
        return getter

    def create_setter(setter_name):
        def setter(self, value):
            setter_target = src_getter(self) if src_getter else self
            return getattr(setter_target, setter_name)(value) if setter_name in dir(setter_target) else None
        return setter

    if not src_cls:
        src_cls = target_cls

    getter_prefix = 'get_'
    setter_prefix = 'set_'
    attrs = {method[len(getter_prefix):] for method in dir(src_cls) if method.startswith(getter_prefix) or method.startswith(setter_prefix)}
    for attr in attrs:
        getter_name = getter_prefix + attr
        setter_name = setter_prefix + attr
        setattr(target_cls, attr, property(
            create_getter(getter_name),
            create_setter(setter_name)
        ))


class Iterator:
    def __init__(self, container, begin, end):
        self.container = container
        self.current = begin
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current != self.end:
            value = self.current.value()
            self.current.next()
            return value
        else:
            raise StopIteration

class SwigPyIterator(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 - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_SwigPyIterator

    def value(self):
        return _manifest.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _manifest.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _manifest.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _manifest.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _manifest.SwigPyIterator_equal(self, x)

    def copy(self):
        return _manifest.SwigPyIterator_copy(self)

    def next(self):
        return _manifest.SwigPyIterator_next(self)

    def __next__(self):
        return _manifest.SwigPyIterator___next__(self)

    def previous(self):
        return _manifest.SwigPyIterator_previous(self)

    def advance(self, n):
        return _manifest.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _manifest.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _manifest.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _manifest.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _manifest.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _manifest.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _manifest.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _manifest:
_manifest.SwigPyIterator_swigregister(SwigPyIterator)
class VectorString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _manifest.VectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _manifest.VectorString___nonzero__(self)

    def __bool__(self):
        return _manifest.VectorString___bool__(self)

    def __len__(self):
        return _manifest.VectorString___len__(self)

    def __getslice__(self, i, j):
        return _manifest.VectorString___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _manifest.VectorString___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _manifest.VectorString___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _manifest.VectorString___delitem__(self, *args)

    def __getitem__(self, *args):
        return _manifest.VectorString___getitem__(self, *args)

    def __setitem__(self, *args):
        return _manifest.VectorString___setitem__(self, *args)

    def pop(self):
        return _manifest.VectorString_pop(self)

    def append(self, x):
        return _manifest.VectorString_append(self, x)

    def empty(self):
        return _manifest.VectorString_empty(self)

    def size(self):
        return _manifest.VectorString_size(self)

    def swap(self, v):
        return _manifest.VectorString_swap(self, v)

    def begin(self):
        return _manifest.VectorString_begin(self)

    def end(self):
        return _manifest.VectorString_end(self)

    def rbegin(self):
        return _manifest.VectorString_rbegin(self)

    def rend(self):
        return _manifest.VectorString_rend(self)

    def clear(self):
        return _manifest.VectorString_clear(self)

    def get_allocator(self):
        return _manifest.VectorString_get_allocator(self)

    def pop_back(self):
        return _manifest.VectorString_pop_back(self)

    def erase(self, *args):
        return _manifest.VectorString_erase(self, *args)

    def __init__(self, *args):
        _manifest.VectorString_swiginit(self, _manifest.new_VectorString(*args))

    def push_back(self, x):
        return _manifest.VectorString_push_back(self, x)

    def front(self):
        return _manifest.VectorString_front(self)

    def back(self):
        return _manifest.VectorString_back(self)

    def assign(self, n, x):
        return _manifest.VectorString_assign(self, n, x)

    def resize(self, *args):
        return _manifest.VectorString_resize(self, *args)

    def insert(self, *args):
        return _manifest.VectorString_insert(self, *args)

    def reserve(self, n):
        return _manifest.VectorString_reserve(self, n)

    def capacity(self):
        return _manifest.VectorString_capacity(self)
    __swig_destroy__ = _manifest.delete_VectorString

# Register VectorString in _manifest:
_manifest.VectorString_swigregister(VectorString)


def VectorString__str__(self):
    return str(list(self))
VectorString.__str__ = VectorString__str__

def VectorString__eq__(self, other):
    return list(self) == list(other)
VectorString.__eq__ = VectorString__eq__

def VectorString__ne__(self, other):
    return list(self) != list(other)
VectorString.__ne__ = VectorString__ne__

def VectorString__lt__(self, other):
    return list(self) < list(other)
VectorString.__lt__ = VectorString__lt__

def VectorString__le__(self, other):
    return list(self) <= list(other)
VectorString.__le__ = VectorString__le__

def VectorString__gt__(self, other):
    return list(self) > list(other)
VectorString.__gt__ = VectorString__gt__

def VectorString__ge__(self, other):
    return list(self) >= list(other)
VectorString.__ge__ = VectorString__ge__

def VectorString__iadd__(self, value):
    self.extend(value)
    return self
VectorString.__iadd__ = VectorString__iadd__

def VectorString__imul__(self, value):
    data = list(self)
    data *= value
    self.clear()
    self.extend(data)
    return self
VectorString.__imul__ = VectorString__imul__

def VectorString__mul__(self, value):
    result = self.copy()
    result *= value
    return result
VectorString.__mul__ = VectorString__mul__

def VectorString__rmul__(self, value):
    return self * value
VectorString.__rmul__ = VectorString__rmul__

def VectorString__add__(self, value):
    result = self.copy()
    result.extend(value)
    return result
VectorString.__add__ = VectorString__add__

def VectorString__append(self, item):
    self.push_back(item)
VectorString.append = VectorString__append

def VectorString__copy(self):
    return VectorString(list(self))
VectorString.copy = VectorString__copy

def VectorString__count(self, item):
    return list(self).count(item)
VectorString.count = VectorString__count

def VectorString__extend(self, iterable):
    for i in iterable:
        self.push_back(i)
VectorString.extend = VectorString__extend

def VectorString__index(self, *args, **kwargs):
    data = list(self)
    return data.index(*args, **kwargs)
VectorString.index = VectorString__index

def VectorString__insert(self, *args, **kwargs):
    data = list(self)
    data.insert(*args, **kwargs)
    self.clear()
    self.extend(data)
VectorString.insert = VectorString__insert

def VectorString__remove(self, *args, **kwargs):
    data = list(self)
    data.remove(*args, **kwargs)
    self.clear()
    self.extend(data)
VectorString.remove = VectorString__remove

def VectorString__sort(self, *args, **kwargs):
    data = list(self)
    data.sort()
    self.clear()
    self.extend(data)
VectorString.sort = VectorString__sort

def VectorString__reverse(self, *args, **kwargs):
    data = list(self)
    data.reverse()
    self.clear()
    self.extend(data)
VectorString.reverse = VectorString__reverse

class Version(object):
    r""" Structure representing a version, supporting up to three components."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Version

    def __init__(self, *args):
        _manifest.Version_swiginit(self, _manifest.new_Version(*args))

    def get_major(self):
        r"""
        Retrieves the major version component.

        :rtype: int
        :return: The major version number.
        """
        return _manifest.Version_get_major(self)

    def get_minor(self):
        r"""
        Retrieves the minor version component.

        :rtype: int
        :return: The minor version number.
        """
        return _manifest.Version_get_minor(self)

    def get_patch(self):
        r"""
        Retrieves the patch version component.

        :rtype: int
        :return: The patch version number.
        """
        return _manifest.Version_get_patch(self)

    def set_major(self, major):
        r"""
        Sets the major version component.

        :type major: int
        :param major: The value of the major version component.
        """
        return _manifest.Version_set_major(self, major)

    def set_minor(self, minor):
        r"""
        Sets the minor version component.

        :type minor: int
        :param minor: The value for the minor version component.
        """
        return _manifest.Version_set_minor(self, minor)

    def set_patch(self, patch):
        r"""
        Sets the patch version component.

        :type patch: int
        :param patch: The value for the patch version component.
        """
        return _manifest.Version_set_patch(self, patch)

# Register Version in _manifest:
_manifest.Version_swigregister(Version)
class Repository(object):
    r""" Represents a single repository within the manifest."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Repository

    def __init__(self, *args):
        _manifest.Repository_swiginit(self, _manifest.new_Repository(*args))

    def get_id(self):
        r"""
        Retrieves the repository ID.

        :rtype: string
        :return: The repository ID.
        """
        return _manifest.Repository_get_id(self)

    def get_baseurl(self):
        r"""
        Retrieves the base URL of the repository.

        :rtype: string
        :return: The base URL.
        """
        return _manifest.Repository_get_baseurl(self)

    def get_metalink(self):
        r"""
        Retrieves the metalink URL of the repository.

        :rtype: string
        :return: The metalink URL.
        """
        return _manifest.Repository_get_metalink(self)

    def get_mirrorlist(self):
        r"""
        Retrieves the mirrorlist URL of the repository.

        :rtype: string
        :return: The mirrorlist URL.
        """
        return _manifest.Repository_get_mirrorlist(self)

    def set_id(self, id):
        r"""
        Sets the repository ID.

        :type id: string
        :param id: The repository ID to set.
        """
        return _manifest.Repository_set_id(self, id)

    def set_baseurl(self, baseurl):
        r"""
        Sets the base URL of the repository.

        :type baseurl: string
        :param baseurl: The base URL to set.
        """
        return _manifest.Repository_set_baseurl(self, baseurl)

    def set_metalink(self, metalink):
        r"""
        Sets the metalink URL of the repository.

        :type metalink: string
        :param metalink: The metalink URL to set.
        """
        return _manifest.Repository_set_metalink(self, metalink)

    def set_mirrorlist(self, mirrorlist):
        r"""
        Sets the mirrorlist URL of the repository.

        :type mirrorlist: string
        :param mirrorlist: The mirrorlist URL to set.
        """
        return _manifest.Repository_set_mirrorlist(self, mirrorlist)

# Register Repository in _manifest:
_manifest.Repository_swigregister(Repository)
class NoSuchRepositoryIdError(object):
    r""" Exception thrown when a repository with a given ID does not exist."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, message):
        _manifest.NoSuchRepositoryIdError_swiginit(self, _manifest.new_NoSuchRepositoryIdError(message))
    __swig_destroy__ = _manifest.delete_NoSuchRepositoryIdError

# Register NoSuchRepositoryIdError in _manifest:
_manifest.NoSuchRepositoryIdError_swigregister(NoSuchRepositoryIdError)
class Repositories(object):
    r""" A container for all repositories listed in the manifest."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Repositories

    def __init__(self, *args):
        _manifest.Repositories_swiginit(self, _manifest.new_Repositories(*args))

    def contains(self, id):
        r"""
        Checks if a given repository exists.

        :type id: string
        :param id: The repository ID.
        :rtype: boolean
        :return: True if the given repository exists; otherwise, false.
        """
        return _manifest.Repositories_contains(self, id)

    def size(self):
        r"""
        Gets the number of repositories in the container.

        :rtype: std::size_t
        :return: The size of the repositories container.
        """
        return _manifest.Repositories_size(self)

    def get(self, id):
        r"""
        Retrieves a repository by its ID.

        :type id: string
        :param id: The repository ID.
        :rtype: :py:class:`Repository`
        :return: A repository with the given ID.
        """
        return _manifest.Repositories_get(self, id)

    def add(self, repository):
        r"""
        Adds a repository to the container.

        :type repository: :py:class:`Repository`
        :param repository: The repository to add.
        """
        return _manifest.Repositories_add(self, repository)

    def begin(self):
        r""" Returns an iterator to the beginning of the container."""
        return _manifest.Repositories_begin(self)

    def end(self):
        r""" Returns an iterator to the end of the container."""
        return _manifest.Repositories_end(self)

    def __getitem__(self, id):
        return _manifest.Repositories___getitem__(self, id)

    def __setitem__(self, id, repository):
        return _manifest.Repositories___setitem__(self, id, repository)

    def __contains__(self, id):
        return _manifest.Repositories___contains__(self, id)

    def __len__(self):
        return _manifest.Repositories___len__(self)

# Register Repositories in _manifest:
_manifest.Repositories_swigregister(Repositories)
class RepositoriesIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_RepositoriesIterator

    def __init__(self, *args):
        _manifest.RepositoriesIterator_swiginit(self, _manifest.new_RepositoriesIterator(*args))

    def value(self):
        return _manifest.RepositoriesIterator_value(self)

    def next(self):
        return _manifest.RepositoriesIterator_next(self)

    def __ne__(self, other):
        return _manifest.RepositoriesIterator___ne__(self, other)

# Register RepositoriesIterator in _manifest:
_manifest.RepositoriesIterator_swigregister(RepositoriesIterator)
class MapRepositories(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _manifest.MapRepositories_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _manifest.MapRepositories___nonzero__(self)

    def __bool__(self):
        return _manifest.MapRepositories___bool__(self)

    def __len__(self):
        return _manifest.MapRepositories___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _manifest.MapRepositories___getitem__(self, key)

    def __delitem__(self, key):
        return _manifest.MapRepositories___delitem__(self, key)

    def has_key(self, key):
        return _manifest.MapRepositories_has_key(self, key)

    def keys(self):
        return _manifest.MapRepositories_keys(self)

    def values(self):
        return _manifest.MapRepositories_values(self)

    def items(self):
        return _manifest.MapRepositories_items(self)

    def __contains__(self, key):
        return _manifest.MapRepositories___contains__(self, key)

    def key_iterator(self):
        return _manifest.MapRepositories_key_iterator(self)

    def value_iterator(self):
        return _manifest.MapRepositories_value_iterator(self)

    def __setitem__(self, *args):
        return _manifest.MapRepositories___setitem__(self, *args)

    def asdict(self):
        return _manifest.MapRepositories_asdict(self)

    def __init__(self, *args):
        _manifest.MapRepositories_swiginit(self, _manifest.new_MapRepositories(*args))

    def empty(self):
        return _manifest.MapRepositories_empty(self)

    def size(self):
        return _manifest.MapRepositories_size(self)

    def swap(self, v):
        return _manifest.MapRepositories_swap(self, v)

    def begin(self):
        return _manifest.MapRepositories_begin(self)

    def end(self):
        return _manifest.MapRepositories_end(self)

    def rbegin(self):
        return _manifest.MapRepositories_rbegin(self)

    def rend(self):
        return _manifest.MapRepositories_rend(self)

    def clear(self):
        return _manifest.MapRepositories_clear(self)

    def get_allocator(self):
        return _manifest.MapRepositories_get_allocator(self)

    def count(self, x):
        return _manifest.MapRepositories_count(self, x)

    def erase(self, *args):
        return _manifest.MapRepositories_erase(self, *args)

    def find(self, x):
        return _manifest.MapRepositories_find(self, x)

    def lower_bound(self, x):
        return _manifest.MapRepositories_lower_bound(self, x)

    def upper_bound(self, x):
        return _manifest.MapRepositories_upper_bound(self, x)
    __swig_destroy__ = _manifest.delete_MapRepositories

# Register MapRepositories in _manifest:
_manifest.MapRepositories_swigregister(MapRepositories)

def Repositories__iter__(self):
    return Iterator(self, self.begin(), self.end())
Repositories.__iter__ = Repositories__iter__
del Repositories__iter__


add_property_accessors(Repository)
add_property_accessors(Version)

ChecksumMethod_SHA1 = _manifest.ChecksumMethod_SHA1
ChecksumMethod_SHA224 = _manifest.ChecksumMethod_SHA224
ChecksumMethod_SHA256 = _manifest.ChecksumMethod_SHA256
ChecksumMethod_SHA384 = _manifest.ChecksumMethod_SHA384
ChecksumMethod_SHA512 = _manifest.ChecksumMethod_SHA512
ChecksumMethod_MD5 = _manifest.ChecksumMethod_MD5
ChecksumMethod_CRC32 = _manifest.ChecksumMethod_CRC32
ChecksumMethod_CRC64 = _manifest.ChecksumMethod_CRC64
class Checksum(object):
    r""" Stores information about the package checksum."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Checksum

    def __init__(self, *args):
        _manifest.Checksum_swiginit(self, _manifest.new_Checksum(*args))

    def get_method(self):
        r"""
        Retrieves the method used for calculating the checksum.

        :rtype: int
        :return: The checksum calculation method.
        """
        return _manifest.Checksum_get_method(self)

    def get_digest(self):
        r"""
        Retrieves the output of the checksum hash function.

        :rtype: string
        :return: The checksum digest.
        """
        return _manifest.Checksum_get_digest(self)

    def set_method(self, method):
        r"""
        Sets the method used for calculating the checksum.

        :type method: int
        :param method: The checksum calculation method to be used.
        """
        return _manifest.Checksum_set_method(self, method)

    def set_digest(self, digest):
        r"""
        Sets the output of the checksum hash function.

        :type digest: string
        :param digest: The checksum digest to be set.
        """
        return _manifest.Checksum_set_digest(self, digest)

# Register Checksum in _manifest:
_manifest.Checksum_swigregister(Checksum)
class Module(object):
    r"""
    A structure that holds modularity-related information about the package.

    Notes: For more details, refer to the official Modularity project documentation: https://docs.fedoraproject.org/en-US/modularity/.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Module

    def __init__(self, *args):
        _manifest.Module_swiginit(self, _manifest.new_Module(*args))

    def get_name(self):
        r"""
        Retrieves the Name of the module to which the package belongs.

        :rtype: string
        :return: A string representing the module name.
        """
        return _manifest.Module_get_name(self)

    def get_stream(self):
        r"""
        Retrieves the stream identifier, which indicates the specific version or variant of the module.

        :rtype: string
        :return: A string representing the stream identifier.
        """
        return _manifest.Module_get_stream(self)

    def set_name(self, name):
        r"""
        Sets the name of the module to which the package belongs.

        :type name: string
        :param name: A string containing the module name.
        """
        return _manifest.Module_set_name(self, name)

    def set_stream(self, stream):
        r"""
        Sets the stream identifier, which typically represents the version or variant of the module.

        :type stream: string
        :param stream: A string containing the stream identifier.
        """
        return _manifest.Module_set_stream(self, stream)

# Register Module in _manifest:
_manifest.Module_swigregister(Module)
class Nevra(object):
    r"""
    Format for the package identifier, including Name, (optional) Epoch, Version, Release, and Architecture fields.

    Notes: For more details, refer to the official RPM documentation: https://rpm-software-management.github.io/rpm/manual/tags.html.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Nevra

    def __init__(self, *args):
        _manifest.Nevra_swiginit(self, _manifest.new_Nevra(*args))

    def get_name(self):
        r"""
        Retrieves the package name.

        :rtype: string
        :return: The package name.
        """
        return _manifest.Nevra_get_name(self)

    def get_epoch(self):
        r"""
        Retrieves the package epoch.

        Notes: Can be empty if the epoch is not defined.

        :rtype: string
        :return: The package epoch.
        """
        return _manifest.Nevra_get_epoch(self)

    def get_version(self):
        r"""
        Retrieves the package version.

        :rtype: string
        :return: The package version.
        """
        return _manifest.Nevra_get_version(self)

    def get_release(self):
        r"""
        Retrieves the package release.

        :rtype: string
        :return: The package release.
        """
        return _manifest.Nevra_get_release(self)

    def get_arch(self):
        r"""
        Retrieves the package architecture.

        :rtype: string
        :return: The package architecture.
        """
        return _manifest.Nevra_get_arch(self)

    def set_name(self, name):
        r"""
        Sets the package name.

        :type name: string
        :param name: The package name.
        """
        return _manifest.Nevra_set_name(self, name)

    def set_epoch(self, epoch):
        r"""
        Sets the package epoch.

        :type epoch: string
        :param epoch: The package epoch.
        """
        return _manifest.Nevra_set_epoch(self, epoch)

    def set_version(self, version):
        r"""
        Sets package version.

        :type version: string
        :param version: The package version.
        """
        return _manifest.Nevra_set_version(self, version)

    def set_release(self, release):
        r"""
        Sets the package release.

        :type release: string
        :param release: The package release.
        """
        return _manifest.Nevra_set_release(self, release)

    def set_arch(self, arch):
        r"""
        Sets the package architecture.

        :type arch: string
        :param arch: The package architecture.
        """
        return _manifest.Nevra_set_arch(self, arch)

    def to_string(self):
        r"""
        Converts the NEVRA object to its full string representation.

        :rtype: string
        :return: The NEVRA string.
        """
        return _manifest.Nevra_to_string(self)

    def __str__(self):
        return _manifest.Nevra___str__(self)

# Register Nevra in _manifest:
_manifest.Nevra_swigregister(Nevra)
class Package(object):
    r""" Represents a single package within the manifest."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Package

    def __init__(self, *args):
        _manifest.Package_swiginit(self, _manifest.new_Package(*args))

    def get_repo_id(self):
        r"""
        Retrieves the repository identifier the packages is from.

        :rtype: string
        :return: The repository ID.
        """
        return _manifest.Package_get_repo_id(self)

    def get_location(self):
        r"""
        Retrieves the package's relative path within the repository.

        :rtype: string
        :return: The package's relative path.
        """
        return _manifest.Package_get_location(self)

    def get_url(self):
        r"""
        Retrieves the complete URL for downloading the package.

        Notes: Constructed by combining the repository URL and the package's relative location path.

        :rtype: string
        :return: The full URL of the package.
        """
        return _manifest.Package_get_url(self)

    def get_size(self):
        r"""
        Retrieves the download size of the package in bytes.

        :rtype: int
        :return: The size of the package in bytes.
        """
        return _manifest.Package_get_size(self)

    def get_repository(self):
        r"""
        Retrieves the repository where the package originates.

        :rtype: :py:class:`Repository`
        :return: The repository object.
        """
        return _manifest.Package_get_repository(self)

    def get_checksum(self):
        r"""
        Retrieves the checksum associated with this package.

        :rtype: :py:class:`Checksum`
        :return: The package checksum.
        """
        return _manifest.Package_get_checksum(self)

    def get_nevra(self):
        r"""
        Retrieves the NEVRA package identifier.

        :rtype: :py:class:`Nevra`
        :return: The NEVRA identifier of the package.
        """
        return _manifest.Package_get_nevra(self)

    def get_srpm(self):
        r"""
        Retrieves the NEVRA identifier of the source package.

        Notes: This identifies the source package used to build this binary package.

        :rtype: :py:class:`Nevra`
        :return: The NEVRA identifier of the source package.
        """
        return _manifest.Package_get_srpm(self)

    def get_module(self):
        r"""
        Retrieves the module information associated with this package.

        :rtype: :py:class:`Module`
        :return: The package module.
        """
        return _manifest.Package_get_module(self)

    def set_repo_id(self, repo_id):
        r"""
        Sets the repository identifier the package is from.

        :type repo_id: string
        :param repo_id: The repository ID to be set.
        """
        return _manifest.Package_set_repo_id(self, repo_id)

    def set_location(self, location):
        r"""
        Sets the package's relative path within the repository.

        :type location: string
        :param location: The path to be set for the package.
        """
        return _manifest.Package_set_location(self, location)

    def set_size(self, size):
        r"""
        Sets the download size of the package in bytes.

        :type size: int
        :param size: The size of the package in bytes to be set.
        """
        return _manifest.Package_set_size(self, size)

    def set_checksum(self, checksum):
        r"""
        Sets the checksum associated with this package.

        :type checksum: :py:class:`Checksum`
        :param checksum: The checksum to be set for the package.
        """
        return _manifest.Package_set_checksum(self, checksum)

    def set_nevra(self, nevra):
        r"""
        Sets the package NEVRA identifier.

        :type nevra: :py:class:`Nevra`
        :param nevra: The NEVRA identifier to be set for the package.
        """
        return _manifest.Package_set_nevra(self, nevra)

    def set_srpm(self, srpm):
        r"""
        Sets the source package NEVRA identifier.

        Notes: This identifies the source package used to build this binary package.

        :type srpm: :py:class:`Nevra`
        :param srpm: The source RPM NEVRA to be set for the package.
        """
        return _manifest.Package_set_srpm(self, srpm)

    def set_module(self, module):
        r"""
        Sets the module information associated with this package.

        :type module: :py:class:`Module`
        :param module: The module to be set for the package.
        """
        return _manifest.Package_set_module(self, module)

    def attach(self, repositories):
        r"""
        Binds the repositories to the package object.

        Notes: Used to reference and validate repository-related information within the package.

        :type repositories: :py:class:`Repositories`
        :param repositories: The repositories object to bind.
        """
        return _manifest.Package_attach(self, repositories)

# Register Package in _manifest:
_manifest.Package_swigregister(Package)
class VectorPackage(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _manifest.VectorPackage_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _manifest.VectorPackage___nonzero__(self)

    def __bool__(self):
        return _manifest.VectorPackage___bool__(self)

    def __len__(self):
        return _manifest.VectorPackage___len__(self)

    def __getslice__(self, i, j):
        return _manifest.VectorPackage___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _manifest.VectorPackage___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _manifest.VectorPackage___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _manifest.VectorPackage___delitem__(self, *args)

    def __getitem__(self, *args):
        return _manifest.VectorPackage___getitem__(self, *args)

    def __setitem__(self, *args):
        return _manifest.VectorPackage___setitem__(self, *args)

    def pop(self):
        return _manifest.VectorPackage_pop(self)

    def append(self, x):
        return _manifest.VectorPackage_append(self, x)

    def empty(self):
        return _manifest.VectorPackage_empty(self)

    def size(self):
        return _manifest.VectorPackage_size(self)

    def swap(self, v):
        return _manifest.VectorPackage_swap(self, v)

    def begin(self):
        return _manifest.VectorPackage_begin(self)

    def end(self):
        return _manifest.VectorPackage_end(self)

    def rbegin(self):
        return _manifest.VectorPackage_rbegin(self)

    def rend(self):
        return _manifest.VectorPackage_rend(self)

    def clear(self):
        return _manifest.VectorPackage_clear(self)

    def get_allocator(self):
        return _manifest.VectorPackage_get_allocator(self)

    def pop_back(self):
        return _manifest.VectorPackage_pop_back(self)

    def erase(self, *args):
        return _manifest.VectorPackage_erase(self, *args)

    def __init__(self, *args):
        _manifest.VectorPackage_swiginit(self, _manifest.new_VectorPackage(*args))

    def push_back(self, x):
        return _manifest.VectorPackage_push_back(self, x)

    def front(self):
        return _manifest.VectorPackage_front(self)

    def back(self):
        return _manifest.VectorPackage_back(self)

    def assign(self, n, x):
        return _manifest.VectorPackage_assign(self, n, x)

    def insert(self, *args):
        return _manifest.VectorPackage_insert(self, *args)

    def reserve(self, n):
        return _manifest.VectorPackage_reserve(self, n)

    def capacity(self):
        return _manifest.VectorPackage_capacity(self)
    __swig_destroy__ = _manifest.delete_VectorPackage

# Register VectorPackage in _manifest:
_manifest.VectorPackage_swigregister(VectorPackage)
class Packages(object):
    r""" A container for all packages listed in the manifest."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Packages

    def __init__(self, *args):
        _manifest.Packages_swiginit(self, _manifest.new_Packages(*args))

    def get(self, *args):
        r"""
        *Overload 1:*
        Retrieves a list of all packages in the container.

        :rtype: std::vector< libpkgmanifest::manifest::Package,std::allocator< libpkgmanifest::manifest::Package > >
        :return: A vector containing all packages.

        |

        *Overload 2:*
        Retrieves a list of packages filtered by the specified base architecture.

        :type basearch: string
        :param basearch: The base architecture used to filter the packages.
        :type with_source: boolean, optional
        :param with_source: True if source packages should be included in the result.
        :rtype: std::vector< libpkgmanifest::manifest::Package,std::allocator< libpkgmanifest::manifest::Package > >
        :return: A vector containing the packages for the specified base architecture.

        |

        *Overload 3:*
        Retrieves a list of packages filtered by the specified base architecture.

        :type basearch: string
        :param basearch: The base architecture used to filter the packages.
        :param with_source: True if source packages should be included in the result.
        :rtype: std::vector< libpkgmanifest::manifest::Package,std::allocator< libpkgmanifest::manifest::Package > >
        :return: A vector containing the packages for the specified base architecture.
        """
        return _manifest.Packages_get(self, *args)

    def add(self, *args):
        r"""
        *Overload 1:*
        Adds a given package to the container.

        Notes: The package is categorized within the container based on its architecture.

        :type package: :py:class:`Package`
        :param package: The package to be added.

        |

        *Overload 2:*
        Adds a given package to the container and link it to the given base architecture.

        Notes: Used when storing multiple base architectures in a manifest file.

        :type package: :py:class:`Package`
        :param package: The package to be added.
        :type basearch: string
        :param basearch: The base architecture to link the package to.
        """
        return _manifest.Packages_add(self, *args)

    def contains(self, package):
        r"""
        Verifies if the given package exists in the container.

        Notes: Packages are considered identical if they share the same NEVRA and repository ID.

        :rtype: boolean
        :return: True if the package is present in the container.
        """
        return _manifest.Packages_contains(self, package)

    def attach(self, repositories):
        r"""
        Binds the repositories to the packages object.

        Notes: Used to reference and validate repository-related information within the packages.

        :type repositories: :py:class:`Repositories`
        :param repositories: The repositories object to bind.
        """
        return _manifest.Packages_attach(self, repositories)

    def __getitem__(self, key):
        return _manifest.Packages___getitem__(self, key)

    def values(self):
        return _manifest.Packages_values(self)

# Register Packages in _manifest:
_manifest.Packages_swigregister(Packages)
class MapPackages(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _manifest.MapPackages_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _manifest.MapPackages___nonzero__(self)

    def __bool__(self):
        return _manifest.MapPackages___bool__(self)

    def __len__(self):
        return _manifest.MapPackages___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _manifest.MapPackages___getitem__(self, key)

    def __delitem__(self, key):
        return _manifest.MapPackages___delitem__(self, key)

    def has_key(self, key):
        return _manifest.MapPackages_has_key(self, key)

    def keys(self):
        return _manifest.MapPackages_keys(self)

    def values(self):
        return _manifest.MapPackages_values(self)

    def items(self):
        return _manifest.MapPackages_items(self)

    def __contains__(self, key):
        return _manifest.MapPackages___contains__(self, key)

    def key_iterator(self):
        return _manifest.MapPackages_key_iterator(self)

    def value_iterator(self):
        return _manifest.MapPackages_value_iterator(self)

    def __setitem__(self, *args):
        return _manifest.MapPackages___setitem__(self, *args)

    def asdict(self):
        return _manifest.MapPackages_asdict(self)

    def __init__(self, *args):
        _manifest.MapPackages_swiginit(self, _manifest.new_MapPackages(*args))

    def empty(self):
        return _manifest.MapPackages_empty(self)

    def size(self):
        return _manifest.MapPackages_size(self)

    def swap(self, v):
        return _manifest.MapPackages_swap(self, v)

    def begin(self):
        return _manifest.MapPackages_begin(self)

    def end(self):
        return _manifest.MapPackages_end(self)

    def rbegin(self):
        return _manifest.MapPackages_rbegin(self)

    def rend(self):
        return _manifest.MapPackages_rend(self)

    def clear(self):
        return _manifest.MapPackages_clear(self)

    def get_allocator(self):
        return _manifest.MapPackages_get_allocator(self)

    def count(self, x):
        return _manifest.MapPackages_count(self, x)

    def erase(self, *args):
        return _manifest.MapPackages_erase(self, *args)

    def find(self, x):
        return _manifest.MapPackages_find(self, x)

    def lower_bound(self, x):
        return _manifest.MapPackages_lower_bound(self, x)

    def upper_bound(self, x):
        return _manifest.MapPackages_upper_bound(self, x)
    __swig_destroy__ = _manifest.delete_MapPackages

# Register MapPackages in _manifest:
_manifest.MapPackages_swigregister(MapPackages)
class Manifest(object):
    r""" The primary data class that stores all information related to the items in the manifest file."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _manifest.delete_Manifest

    def __init__(self, *args):
        _manifest.Manifest_swiginit(self, _manifest.new_Manifest(*args))

    def get_document(self):
        r"""
        Retrieves the YAML document identifier.

        Notes: This is expected to be the value "rpm-package-manifest".

        :rtype: string
        :return: The document identifier.
        """
        return _manifest.Manifest_get_document(self)

    def get_version(self):
        r"""
        Retrieves the version of the YAML document.

        Notes: This version changes if the structure or format of the document's properties has been updated.

        :rtype: :py:class:`Version`
        :return: The document version.
        """
        return _manifest.Manifest_get_version(self)

    def get_packages(self):
        r"""
        Retrieves a structure containing all the packages defined in the manifest file.

        :rtype: :py:class:`Packages`
        :return: A structure with the packages listed in the manifest.
        """
        return _manifest.Manifest_get_packages(self)

    def get_repositories(self):
        r"""
        Retrieves a structure containing all the repositories defined in the manifest file.

        :rtype: :py:class:`Repositories`
        :return: A structure with the repositories listed in the manifest.
        """
        return _manifest.Manifest_get_repositories(self)

    def set_document(self, document):
        r"""
        Sets the YAML document identifier.

        :type document: string
        :param document: The YAML identifier to set.
        """
        return _manifest.Manifest_set_document(self, document)

    def set_version(self, version):
        r"""
        Sets the version of the YAML document.

        :type version: :py:class:`Version`
        :param version: The version to set for the document.
        """
        return _manifest.Manifest_set_version(self, version)

    def set_packages(self, packages):
        r"""
        Assigns a structure with all the packages to be included in the manifest file.

        :type packages: :py:class:`Packages`
        :param packages: A structure containing the packages to be set.
        """
        return _manifest.Manifest_set_packages(self, packages)

    def set_repositories(self, repositories):
        r"""
        Assigns a structure with all the repositories to be included in the manifest file.

        :type repositories: :py:class:`Repositories`
        :param repositories: A structure containing the repositories to be set.
        """
        return _manifest.Manifest_set_repositories(self, repositories)

# Register Manifest in _manifest:
_manifest.Manifest_swigregister(Manifest)
class Parser(object):
    r""" A class responsible for parsing the YAML files into objects."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _manifest.Parser_swiginit(self, _manifest.new_Parser())
    __swig_destroy__ = _manifest.delete_Parser

    def parse(self, path):
        r"""
        Parses the manifest file from a specified file path.

        :type path: string
        :param path: The location of the manifest file.
        :rtype: :py:class:`Manifest`
        :return: A manifest object containing data parsed from the file.
        :raises: ParserError if an error occurs during file parsing.
        """
        return _manifest.Parser_parse(self, path)

# Register Parser in _manifest:
_manifest.Parser_swigregister(Parser)
class Serializer(object):
    r""" A class responsible for serializing the manifest object into a YAML file."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _manifest.Serializer_swiginit(self, _manifest.new_Serializer())
    __swig_destroy__ = _manifest.delete_Serializer

    def serialize(self, manifest, path):
        r"""
        Serializes a manifest object to a specified file path.

        :type manifest: :py:class:`Manifest`
        :param manifest: The manifest object containing package data.
        :type path: string
        :param path: The file path where the manifest should be saved.
        :raises: SerializerError if an error occurs during serialization.
        """
        return _manifest.Serializer_serialize(self, manifest, path)

# Register Serializer in _manifest:
_manifest.Serializer_swigregister(Serializer)

add_property_accessors(Checksum)
add_property_accessors(Manifest)
add_property_accessors(Module)
add_property_accessors(Nevra)
add_property_accessors(Package)
add_property_accessors(Package, Nevra, Package.get_nevra)


