# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _module
else:
    import _module

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 == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, 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__)


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__ = _module.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _module:
_module.SwigPyIterator_swigregister(SwigPyIterator)

import libdnf.common_types
class VectorModulePackagePtr(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 _module.VectorModulePackagePtr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.VectorModulePackagePtr___nonzero__(self)

    def __bool__(self):
        return _module.VectorModulePackagePtr___bool__(self)

    def __len__(self):
        return _module.VectorModulePackagePtr___len__(self)

    def __getslice__(self, i, j):
        return _module.VectorModulePackagePtr___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _module.VectorModulePackagePtr___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _module.VectorModulePackagePtr___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _module.VectorModulePackagePtr___delitem__(self, *args)

    def __getitem__(self, *args):
        return _module.VectorModulePackagePtr___getitem__(self, *args)

    def __setitem__(self, *args):
        return _module.VectorModulePackagePtr___setitem__(self, *args)

    def pop(self):
        return _module.VectorModulePackagePtr_pop(self)

    def append(self, x):
        return _module.VectorModulePackagePtr_append(self, x)

    def empty(self):
        return _module.VectorModulePackagePtr_empty(self)

    def size(self):
        return _module.VectorModulePackagePtr_size(self)

    def swap(self, v):
        return _module.VectorModulePackagePtr_swap(self, v)

    def begin(self):
        return _module.VectorModulePackagePtr_begin(self)

    def end(self):
        return _module.VectorModulePackagePtr_end(self)

    def rbegin(self):
        return _module.VectorModulePackagePtr_rbegin(self)

    def rend(self):
        return _module.VectorModulePackagePtr_rend(self)

    def clear(self):
        return _module.VectorModulePackagePtr_clear(self)

    def get_allocator(self):
        return _module.VectorModulePackagePtr_get_allocator(self)

    def pop_back(self):
        return _module.VectorModulePackagePtr_pop_back(self)

    def erase(self, *args):
        return _module.VectorModulePackagePtr_erase(self, *args)

    def __init__(self, *args):
        _module.VectorModulePackagePtr_swiginit(self, _module.new_VectorModulePackagePtr(*args))

    def push_back(self, x):
        return _module.VectorModulePackagePtr_push_back(self, x)

    def front(self):
        return _module.VectorModulePackagePtr_front(self)

    def back(self):
        return _module.VectorModulePackagePtr_back(self)

    def assign(self, n, x):
        return _module.VectorModulePackagePtr_assign(self, n, x)

    def resize(self, *args):
        return _module.VectorModulePackagePtr_resize(self, *args)

    def insert(self, *args):
        return _module.VectorModulePackagePtr_insert(self, *args)

    def reserve(self, n):
        return _module.VectorModulePackagePtr_reserve(self, n)

    def capacity(self):
        return _module.VectorModulePackagePtr_capacity(self)
    __swig_destroy__ = _module.delete_VectorModulePackagePtr

# Register VectorModulePackagePtr in _module:
_module.VectorModulePackagePtr_swigregister(VectorModulePackagePtr)

class VectorVectorVectorModulePackagePtr(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 _module.VectorVectorVectorModulePackagePtr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.VectorVectorVectorModulePackagePtr___nonzero__(self)

    def __bool__(self):
        return _module.VectorVectorVectorModulePackagePtr___bool__(self)

    def __len__(self):
        return _module.VectorVectorVectorModulePackagePtr___len__(self)

    def __getslice__(self, i, j):
        return _module.VectorVectorVectorModulePackagePtr___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _module.VectorVectorVectorModulePackagePtr___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _module.VectorVectorVectorModulePackagePtr___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _module.VectorVectorVectorModulePackagePtr___delitem__(self, *args)

    def __getitem__(self, *args):
        return _module.VectorVectorVectorModulePackagePtr___getitem__(self, *args)

    def __setitem__(self, *args):
        return _module.VectorVectorVectorModulePackagePtr___setitem__(self, *args)

    def pop(self):
        return _module.VectorVectorVectorModulePackagePtr_pop(self)

    def append(self, x):
        return _module.VectorVectorVectorModulePackagePtr_append(self, x)

    def empty(self):
        return _module.VectorVectorVectorModulePackagePtr_empty(self)

    def size(self):
        return _module.VectorVectorVectorModulePackagePtr_size(self)

    def swap(self, v):
        return _module.VectorVectorVectorModulePackagePtr_swap(self, v)

    def begin(self):
        return _module.VectorVectorVectorModulePackagePtr_begin(self)

    def end(self):
        return _module.VectorVectorVectorModulePackagePtr_end(self)

    def rbegin(self):
        return _module.VectorVectorVectorModulePackagePtr_rbegin(self)

    def rend(self):
        return _module.VectorVectorVectorModulePackagePtr_rend(self)

    def clear(self):
        return _module.VectorVectorVectorModulePackagePtr_clear(self)

    def get_allocator(self):
        return _module.VectorVectorVectorModulePackagePtr_get_allocator(self)

    def pop_back(self):
        return _module.VectorVectorVectorModulePackagePtr_pop_back(self)

    def erase(self, *args):
        return _module.VectorVectorVectorModulePackagePtr_erase(self, *args)

    def __init__(self, *args):
        _module.VectorVectorVectorModulePackagePtr_swiginit(self, _module.new_VectorVectorVectorModulePackagePtr(*args))

    def push_back(self, x):
        return _module.VectorVectorVectorModulePackagePtr_push_back(self, x)

    def front(self):
        return _module.VectorVectorVectorModulePackagePtr_front(self)

    def back(self):
        return _module.VectorVectorVectorModulePackagePtr_back(self)

    def assign(self, n, x):
        return _module.VectorVectorVectorModulePackagePtr_assign(self, n, x)

    def resize(self, *args):
        return _module.VectorVectorVectorModulePackagePtr_resize(self, *args)

    def insert(self, *args):
        return _module.VectorVectorVectorModulePackagePtr_insert(self, *args)

    def reserve(self, n):
        return _module.VectorVectorVectorModulePackagePtr_reserve(self, n)

    def capacity(self):
        return _module.VectorVectorVectorModulePackagePtr_capacity(self)
    __swig_destroy__ = _module.delete_VectorVectorVectorModulePackagePtr

# Register VectorVectorVectorModulePackagePtr in _module:
_module.VectorVectorVectorModulePackagePtr_swigregister(VectorVectorVectorModulePackagePtr)

class VectorModuleProfile(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 _module.VectorModuleProfile_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.VectorModuleProfile___nonzero__(self)

    def __bool__(self):
        return _module.VectorModuleProfile___bool__(self)

    def __len__(self):
        return _module.VectorModuleProfile___len__(self)

    def __getslice__(self, i, j):
        return _module.VectorModuleProfile___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _module.VectorModuleProfile___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _module.VectorModuleProfile___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _module.VectorModuleProfile___delitem__(self, *args)

    def __getitem__(self, *args):
        return _module.VectorModuleProfile___getitem__(self, *args)

    def __setitem__(self, *args):
        return _module.VectorModuleProfile___setitem__(self, *args)

    def pop(self):
        return _module.VectorModuleProfile_pop(self)

    def append(self, x):
        return _module.VectorModuleProfile_append(self, x)

    def empty(self):
        return _module.VectorModuleProfile_empty(self)

    def size(self):
        return _module.VectorModuleProfile_size(self)

    def swap(self, v):
        return _module.VectorModuleProfile_swap(self, v)

    def begin(self):
        return _module.VectorModuleProfile_begin(self)

    def end(self):
        return _module.VectorModuleProfile_end(self)

    def rbegin(self):
        return _module.VectorModuleProfile_rbegin(self)

    def rend(self):
        return _module.VectorModuleProfile_rend(self)

    def clear(self):
        return _module.VectorModuleProfile_clear(self)

    def get_allocator(self):
        return _module.VectorModuleProfile_get_allocator(self)

    def pop_back(self):
        return _module.VectorModuleProfile_pop_back(self)

    def erase(self, *args):
        return _module.VectorModuleProfile_erase(self, *args)

    def __init__(self, *args):
        _module.VectorModuleProfile_swiginit(self, _module.new_VectorModuleProfile(*args))

    def push_back(self, x):
        return _module.VectorModuleProfile_push_back(self, x)

    def front(self):
        return _module.VectorModuleProfile_front(self)

    def back(self):
        return _module.VectorModuleProfile_back(self)

    def assign(self, n, x):
        return _module.VectorModuleProfile_assign(self, n, x)

    def resize(self, *args):
        return _module.VectorModuleProfile_resize(self, *args)

    def insert(self, *args):
        return _module.VectorModuleProfile_insert(self, *args)

    def reserve(self, n):
        return _module.VectorModuleProfile_reserve(self, n)

    def capacity(self):
        return _module.VectorModuleProfile_capacity(self)
    __swig_destroy__ = _module.delete_VectorModuleProfile

# Register VectorModuleProfile in _module:
_module.VectorModuleProfile_swigregister(VectorModuleProfile)

class VectorModuleDependencies(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 _module.VectorModuleDependencies_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.VectorModuleDependencies___nonzero__(self)

    def __bool__(self):
        return _module.VectorModuleDependencies___bool__(self)

    def __len__(self):
        return _module.VectorModuleDependencies___len__(self)

    def __getslice__(self, i, j):
        return _module.VectorModuleDependencies___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _module.VectorModuleDependencies___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _module.VectorModuleDependencies___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _module.VectorModuleDependencies___delitem__(self, *args)

    def __getitem__(self, *args):
        return _module.VectorModuleDependencies___getitem__(self, *args)

    def __setitem__(self, *args):
        return _module.VectorModuleDependencies___setitem__(self, *args)

    def pop(self):
        return _module.VectorModuleDependencies_pop(self)

    def append(self, x):
        return _module.VectorModuleDependencies_append(self, x)

    def empty(self):
        return _module.VectorModuleDependencies_empty(self)

    def size(self):
        return _module.VectorModuleDependencies_size(self)

    def swap(self, v):
        return _module.VectorModuleDependencies_swap(self, v)

    def begin(self):
        return _module.VectorModuleDependencies_begin(self)

    def end(self):
        return _module.VectorModuleDependencies_end(self)

    def rbegin(self):
        return _module.VectorModuleDependencies_rbegin(self)

    def rend(self):
        return _module.VectorModuleDependencies_rend(self)

    def clear(self):
        return _module.VectorModuleDependencies_clear(self)

    def get_allocator(self):
        return _module.VectorModuleDependencies_get_allocator(self)

    def pop_back(self):
        return _module.VectorModuleDependencies_pop_back(self)

    def erase(self, *args):
        return _module.VectorModuleDependencies_erase(self, *args)

    def __init__(self, *args):
        _module.VectorModuleDependencies_swiginit(self, _module.new_VectorModuleDependencies(*args))

    def push_back(self, x):
        return _module.VectorModuleDependencies_push_back(self, x)

    def front(self):
        return _module.VectorModuleDependencies_front(self)

    def back(self):
        return _module.VectorModuleDependencies_back(self)

    def assign(self, n, x):
        return _module.VectorModuleDependencies_assign(self, n, x)

    def resize(self, *args):
        return _module.VectorModuleDependencies_resize(self, *args)

    def insert(self, *args):
        return _module.VectorModuleDependencies_insert(self, *args)

    def reserve(self, n):
        return _module.VectorModuleDependencies_reserve(self, n)

    def capacity(self):
        return _module.VectorModuleDependencies_capacity(self)
    __swig_destroy__ = _module.delete_VectorModuleDependencies

# Register VectorModuleDependencies in _module:
_module.VectorModuleDependencies_swigregister(VectorModuleDependencies)

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 _module.VectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register VectorString in _module:
_module.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 MapStringVectorString(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 _module.MapStringVectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.MapStringVectorString___nonzero__(self)

    def __bool__(self):
        return _module.MapStringVectorString___bool__(self)

    def __len__(self):
        return _module.MapStringVectorString___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 _module.MapStringVectorString___getitem__(self, key)

    def __delitem__(self, key):
        return _module.MapStringVectorString___delitem__(self, key)

    def has_key(self, key):
        return _module.MapStringVectorString_has_key(self, key)

    def keys(self):
        return _module.MapStringVectorString_keys(self)

    def values(self):
        return _module.MapStringVectorString_values(self)

    def items(self):
        return _module.MapStringVectorString_items(self)

    def __contains__(self, key):
        return _module.MapStringVectorString___contains__(self, key)

    def key_iterator(self):
        return _module.MapStringVectorString_key_iterator(self)

    def value_iterator(self):
        return _module.MapStringVectorString_value_iterator(self)

    def __setitem__(self, *args):
        return _module.MapStringVectorString___setitem__(self, *args)

    def asdict(self):
        return _module.MapStringVectorString_asdict(self)

    def __init__(self, *args):
        _module.MapStringVectorString_swiginit(self, _module.new_MapStringVectorString(*args))

    def empty(self):
        return _module.MapStringVectorString_empty(self)

    def size(self):
        return _module.MapStringVectorString_size(self)

    def swap(self, v):
        return _module.MapStringVectorString_swap(self, v)

    def begin(self):
        return _module.MapStringVectorString_begin(self)

    def end(self):
        return _module.MapStringVectorString_end(self)

    def rbegin(self):
        return _module.MapStringVectorString_rbegin(self)

    def rend(self):
        return _module.MapStringVectorString_rend(self)

    def clear(self):
        return _module.MapStringVectorString_clear(self)

    def get_allocator(self):
        return _module.MapStringVectorString_get_allocator(self)

    def count(self, x):
        return _module.MapStringVectorString_count(self, x)

    def erase(self, *args):
        return _module.MapStringVectorString_erase(self, *args)

    def find(self, x):
        return _module.MapStringVectorString_find(self, x)

    def lower_bound(self, x):
        return _module.MapStringVectorString_lower_bound(self, x)

    def upper_bound(self, x):
        return _module.MapStringVectorString_upper_bound(self, x)
    __swig_destroy__ = _module.delete_MapStringVectorString

# Register MapStringVectorString in _module:
_module.MapStringVectorString_swigregister(MapStringVectorString)

class VectorMapStringVectorString(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 _module.VectorMapStringVectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.VectorMapStringVectorString___nonzero__(self)

    def __bool__(self):
        return _module.VectorMapStringVectorString___bool__(self)

    def __len__(self):
        return _module.VectorMapStringVectorString___len__(self)

    def __getslice__(self, i, j):
        return _module.VectorMapStringVectorString___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _module.VectorMapStringVectorString___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _module.VectorMapStringVectorString___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _module.VectorMapStringVectorString___delitem__(self, *args)

    def __getitem__(self, *args):
        return _module.VectorMapStringVectorString___getitem__(self, *args)

    def __setitem__(self, *args):
        return _module.VectorMapStringVectorString___setitem__(self, *args)

    def pop(self):
        return _module.VectorMapStringVectorString_pop(self)

    def append(self, x):
        return _module.VectorMapStringVectorString_append(self, x)

    def empty(self):
        return _module.VectorMapStringVectorString_empty(self)

    def size(self):
        return _module.VectorMapStringVectorString_size(self)

    def swap(self, v):
        return _module.VectorMapStringVectorString_swap(self, v)

    def begin(self):
        return _module.VectorMapStringVectorString_begin(self)

    def end(self):
        return _module.VectorMapStringVectorString_end(self)

    def rbegin(self):
        return _module.VectorMapStringVectorString_rbegin(self)

    def rend(self):
        return _module.VectorMapStringVectorString_rend(self)

    def clear(self):
        return _module.VectorMapStringVectorString_clear(self)

    def get_allocator(self):
        return _module.VectorMapStringVectorString_get_allocator(self)

    def pop_back(self):
        return _module.VectorMapStringVectorString_pop_back(self)

    def erase(self, *args):
        return _module.VectorMapStringVectorString_erase(self, *args)

    def __init__(self, *args):
        _module.VectorMapStringVectorString_swiginit(self, _module.new_VectorMapStringVectorString(*args))

    def push_back(self, x):
        return _module.VectorMapStringVectorString_push_back(self, x)

    def front(self):
        return _module.VectorMapStringVectorString_front(self)

    def back(self):
        return _module.VectorMapStringVectorString_back(self)

    def assign(self, n, x):
        return _module.VectorMapStringVectorString_assign(self, n, x)

    def resize(self, *args):
        return _module.VectorMapStringVectorString_resize(self, *args)

    def insert(self, *args):
        return _module.VectorMapStringVectorString_insert(self, *args)

    def reserve(self, n):
        return _module.VectorMapStringVectorString_reserve(self, n)

    def capacity(self):
        return _module.VectorMapStringVectorString_capacity(self)
    __swig_destroy__ = _module.delete_VectorMapStringVectorString

# Register VectorMapStringVectorString in _module:
_module.VectorMapStringVectorString_swigregister(VectorMapStringVectorString)

class VectorVectorString(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 _module.VectorVectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _module.VectorVectorString___nonzero__(self)

    def __bool__(self):
        return _module.VectorVectorString___bool__(self)

    def __len__(self):
        return _module.VectorVectorString___len__(self)

    def __getslice__(self, i, j):
        return _module.VectorVectorString___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _module.VectorVectorString___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _module.VectorVectorString___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _module.VectorVectorString___delitem__(self, *args)

    def __getitem__(self, *args):
        return _module.VectorVectorString___getitem__(self, *args)

    def __setitem__(self, *args):
        return _module.VectorVectorString___setitem__(self, *args)

    def pop(self):
        return _module.VectorVectorString_pop(self)

    def append(self, x):
        return _module.VectorVectorString_append(self, x)

    def empty(self):
        return _module.VectorVectorString_empty(self)

    def size(self):
        return _module.VectorVectorString_size(self)

    def swap(self, v):
        return _module.VectorVectorString_swap(self, v)

    def begin(self):
        return _module.VectorVectorString_begin(self)

    def end(self):
        return _module.VectorVectorString_end(self)

    def rbegin(self):
        return _module.VectorVectorString_rbegin(self)

    def rend(self):
        return _module.VectorVectorString_rend(self)

    def clear(self):
        return _module.VectorVectorString_clear(self)

    def get_allocator(self):
        return _module.VectorVectorString_get_allocator(self)

    def pop_back(self):
        return _module.VectorVectorString_pop_back(self)

    def erase(self, *args):
        return _module.VectorVectorString_erase(self, *args)

    def __init__(self, *args):
        _module.VectorVectorString_swiginit(self, _module.new_VectorVectorString(*args))

    def push_back(self, x):
        return _module.VectorVectorString_push_back(self, x)

    def front(self):
        return _module.VectorVectorString_front(self)

    def back(self):
        return _module.VectorVectorString_back(self)

    def assign(self, n, x):
        return _module.VectorVectorString_assign(self, n, x)

    def resize(self, *args):
        return _module.VectorVectorString_resize(self, *args)

    def insert(self, *args):
        return _module.VectorVectorString_insert(self, *args)

    def reserve(self, n):
        return _module.VectorVectorString_reserve(self, n)

    def capacity(self):
        return _module.VectorVectorString_capacity(self)
    __swig_destroy__ = _module.delete_VectorVectorString

# Register VectorVectorString in _module:
_module.VectorVectorString_swigregister(VectorVectorString)

class ModulePackage(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__ = _module.delete_ModulePackage

    def getNameCStr(self):
        return _module.ModulePackage_getNameCStr(self)

    def getName(self):
        return _module.ModulePackage_getName(self)

    def getStreamCStr(self):
        return _module.ModulePackage_getStreamCStr(self)

    def getStream(self):
        return _module.ModulePackage_getStream(self)

    def getNameStream(self):
        return _module.ModulePackage_getNameStream(self)

    def getNameStreamVersion(self):
        return _module.ModulePackage_getNameStreamVersion(self)

    def getRepoID(self):
        return _module.ModulePackage_getRepoID(self)

    def getVersion(self):
        return _module.ModulePackage_getVersion(self)

    def getVersionNum(self):
        return _module.ModulePackage_getVersionNum(self)

    def getContextCStr(self):
        return _module.ModulePackage_getContextCStr(self)

    def getContext(self):
        return _module.ModulePackage_getContext(self)

    def getArchCStr(self):
        return _module.ModulePackage_getArchCStr(self)

    def getArch(self):
        return _module.ModulePackage_getArch(self)

    def getFullIdentifier(self):
        return _module.ModulePackage_getFullIdentifier(self)

    def getSummary(self):
        return _module.ModulePackage_getSummary(self)

    def getDescription(self):
        return _module.ModulePackage_getDescription(self)

    def getArtifacts(self):
        return _module.ModulePackage_getArtifacts(self)

    def __eq__(self, r):
        return _module.ModulePackage___eq__(self, r)

    def getProfiles(self, *args):
        return _module.ModulePackage_getProfiles(self, *args)

    def getModuleDependencies(self):
        return _module.ModulePackage_getModuleDependencies(self)

    def addStreamConflict(self, package):
        return _module.ModulePackage_addStreamConflict(self, package)

    def getId(self):
        return _module.ModulePackage_getId(self)

    def getYaml(self):
        return _module.ModulePackage_getYaml(self)

    def getStaticContext(self):
        return _module.ModulePackage_getStaticContext(self)

    def getRequires(self, removePlatform=False):
        return _module.ModulePackage_getRequires(self, removePlatform)

    def __hash__(self):
        return _module.ModulePackage___hash__(self)

# Register ModulePackage in _module:
_module.ModulePackage_swigregister(ModulePackage)

class ModulePackageContainer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ModuleState_UNKNOWN = _module.ModulePackageContainer_ModuleState_UNKNOWN
    ModuleState_ENABLED = _module.ModulePackageContainer_ModuleState_ENABLED
    ModuleState_DISABLED = _module.ModulePackageContainer_ModuleState_DISABLED
    ModuleState_DEFAULT = _module.ModulePackageContainer_ModuleState_DEFAULT
    ModuleState_INSTALLED = _module.ModulePackageContainer_ModuleState_INSTALLED
    ModuleErrorType_NO_ERROR = _module.ModulePackageContainer_ModuleErrorType_NO_ERROR
    ModuleErrorType_INFO = _module.ModulePackageContainer_ModuleErrorType_INFO
    ModuleErrorType_ERROR_IN_DEFAULTS = _module.ModulePackageContainer_ModuleErrorType_ERROR_IN_DEFAULTS
    ModuleErrorType_ERROR = _module.ModulePackageContainer_ModuleErrorType_ERROR
    ModuleErrorType_CANNOT_RESOLVE_MODULES = _module.ModulePackageContainer_ModuleErrorType_CANNOT_RESOLVE_MODULES
    ModuleErrorType_CANNOT_RESOLVE_MODULE_SPEC = _module.ModulePackageContainer_ModuleErrorType_CANNOT_RESOLVE_MODULE_SPEC
    ModuleErrorType_CANNOT_ENABLE_MULTIPLE_STREAMS = _module.ModulePackageContainer_ModuleErrorType_CANNOT_ENABLE_MULTIPLE_STREAMS
    ModuleErrorType_CANNOT_MODIFY_MULTIPLE_TIMES_MODULE_STATE = _module.ModulePackageContainer_ModuleErrorType_CANNOT_MODIFY_MULTIPLE_TIMES_MODULE_STATE
    ModuleErrorType_ERROR_IN_LATEST = _module.ModulePackageContainer_ModuleErrorType_ERROR_IN_LATEST

    def __init__(self, allArch, installRoot, arch, persistDir=None):
        _module.ModulePackageContainer_swiginit(self, _module.new_ModulePackageContainer(allArch, installRoot, arch, persistDir))
    __swig_destroy__ = _module.delete_ModulePackageContainer

    def add(self, *args):
        return _module.ModulePackageContainer_add(self, *args)

    def addDefaultsFromDisk(self):
        return _module.ModulePackageContainer_addDefaultsFromDisk(self)

    def moduleDefaultsResolve(self):
        return _module.ModulePackageContainer_moduleDefaultsResolve(self)

    def addPlatformPackage(self, *args):
        return _module.ModulePackageContainer_addPlatformPackage(self, *args)

    def createConflictsBetweenStreams(self):
        return _module.ModulePackageContainer_createConflictsBetweenStreams(self)

    def empty(self):
        return _module.ModulePackageContainer_empty(self)

    def getModulePackage(self, id):
        return _module.ModulePackageContainer_getModulePackage(self, id)

    def getModulePackages(self):
        return _module.ModulePackageContainer_getModulePackages(self)

    def getLatestModulesPerRepo(self, moduleFilter, modulePackages):
        return _module.ModulePackageContainer_getLatestModulesPerRepo(self, moduleFilter, modulePackages)

    def requiresModuleEnablement(self, packages):
        return _module.ModulePackageContainer_requiresModuleEnablement(self, packages)

    def enable(self, *args):
        return _module.ModulePackageContainer_enable(self, *args)

    def disable(self, *args):
        return _module.ModulePackageContainer_disable(self, *args)

    def reset(self, *args):
        return _module.ModulePackageContainer_reset(self, *args)

    def install(self, *args):
        return _module.ModulePackageContainer_install(self, *args)

    def uninstall(self, *args):
        return _module.ModulePackageContainer_uninstall(self, *args)

    def save(self):
        return _module.ModulePackageContainer_save(self)

    def rollback(self):
        return _module.ModulePackageContainer_rollback(self)

    def isChanged(self):
        return _module.ModulePackageContainer_isChanged(self)

    def isEnabled(self, *args):
        return _module.ModulePackageContainer_isEnabled(self, *args)

    def isDisabled(self, *args):
        return _module.ModulePackageContainer_isDisabled(self, *args)

    def getModuleState(self, name):
        return _module.ModulePackageContainer_getModuleState(self, name)

    def getInstalledPkgNames(self):
        return _module.ModulePackageContainer_getInstalledPkgNames(self)

    def getReport(self):
        return _module.ModulePackageContainer_getReport(self)

    def getDefaultProfiles(self, moduleName, moduleStream):
        return _module.ModulePackageContainer_getDefaultProfiles(self, moduleName, moduleStream)

    def getDefaultStream(self, name):
        return _module.ModulePackageContainer_getDefaultStream(self, name)

    def getEnabledStream(self, name):
        return _module.ModulePackageContainer_getEnabledStream(self, name)

    def getEnabledStreams(self):
        return _module.ModulePackageContainer_getEnabledStreams(self)

    def getDisabledModules(self):
        return _module.ModulePackageContainer_getDisabledModules(self)

    def getDisabledStreams(self):
        return _module.ModulePackageContainer_getDisabledStreams(self)

    def getResetModules(self):
        return _module.ModulePackageContainer_getResetModules(self)

    def getResetStreams(self):
        return _module.ModulePackageContainer_getResetStreams(self)

    def getSwitchedStreams(self):
        return _module.ModulePackageContainer_getSwitchedStreams(self)

    def getInstalledProfiles(self, *args):
        return _module.ModulePackageContainer_getInstalledProfiles(self, *args)

    def getRemovedProfiles(self):
        return _module.ModulePackageContainer_getRemovedProfiles(self)

    def query(self, *args):
        return _module.ModulePackageContainer_query(self, *args)

    def enableDependencyTree(self, modulePackages):
        return _module.ModulePackageContainer_enableDependencyTree(self, modulePackages)

    def resolveActiveModulePackages(self, debugSolver):
        return _module.ModulePackageContainer_resolveActiveModulePackages(self, debugSolver)

    def isModuleActive(self, *args):
        return _module.ModulePackageContainer_isModuleActive(self, *args)

    def loadFailSafeData(self):
        return _module.ModulePackageContainer_loadFailSafeData(self)

    def updateFailSafeData(self):
        return _module.ModulePackageContainer_updateFailSafeData(self)

    def applyObsoletes(self):
        return _module.ModulePackageContainer_applyObsoletes(self)

# Register ModulePackageContainer in _module:
_module.ModulePackageContainer_swigregister(ModulePackageContainer)

class ModuleProfile(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, *args):
        _module.ModuleProfile_swiginit(self, _module.new_ModuleProfile(*args))
    __swig_destroy__ = _module.delete_ModuleProfile

    def getName(self):
        return _module.ModuleProfile_getName(self)

    def getDescription(self):
        return _module.ModuleProfile_getDescription(self)

    def getContent(self):
        return _module.ModuleProfile_getContent(self)

# Register ModuleProfile in _module:
_module.ModuleProfile_swigregister(ModuleProfile)

class ModuleDependencies(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, *args):
        _module.ModuleDependencies_swiginit(self, _module.new_ModuleDependencies(*args))
    __swig_destroy__ = _module.delete_ModuleDependencies

    def getRequires(self):
        return _module.ModuleDependencies_getRequires(self)

# Register ModuleDependencies in _module:
_module.ModuleDependencies_swigregister(ModuleDependencies)

class PairVectorVectorStringModuleErrorType(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, *args):
        _module.PairVectorVectorStringModuleErrorType_swiginit(self, _module.new_PairVectorVectorStringModuleErrorType(*args))
    first = property(_module.PairVectorVectorStringModuleErrorType_first_get, _module.PairVectorVectorStringModuleErrorType_first_set)
    second = property(_module.PairVectorVectorStringModuleErrorType_second_get, _module.PairVectorVectorStringModuleErrorType_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _module.delete_PairVectorVectorStringModuleErrorType

# Register PairVectorVectorStringModuleErrorType in _module:
_module.PairVectorVectorStringModuleErrorType_swigregister(PairVectorVectorStringModuleErrorType)



