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

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

import builtins as __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


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


import weakref

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _transaction:
_transaction.SwigPyIterator_swigregister(SwigPyIterator)
from . import common
from . import exception
TransactionItemAction_INSTALL = _transaction.TransactionItemAction_INSTALL
TransactionItemAction_UPGRADE = _transaction.TransactionItemAction_UPGRADE
TransactionItemAction_DOWNGRADE = _transaction.TransactionItemAction_DOWNGRADE
TransactionItemAction_REINSTALL = _transaction.TransactionItemAction_REINSTALL
TransactionItemAction_REMOVE = _transaction.TransactionItemAction_REMOVE
TransactionItemAction_REPLACED = _transaction.TransactionItemAction_REPLACED
TransactionItemAction_REASON_CHANGE = _transaction.TransactionItemAction_REASON_CHANGE
TransactionItemAction_ENABLE = _transaction.TransactionItemAction_ENABLE
TransactionItemAction_DISABLE = _transaction.TransactionItemAction_DISABLE
TransactionItemAction_RESET = _transaction.TransactionItemAction_RESET
TransactionItemAction_SWITCH = _transaction.TransactionItemAction_SWITCH

def transaction_item_action_to_string(action):
    return _transaction.transaction_item_action_to_string(action)

def transaction_item_action_to_translated_string(action):
    return _transaction.transaction_item_action_to_translated_string(action)

def transaction_item_action_from_string(action):
    return _transaction.transaction_item_action_from_string(action)

def transaction_item_action_to_letter(action):
    return _transaction.transaction_item_action_to_letter(action)

def transaction_item_action_is_inbound(action):
    return _transaction.transaction_item_action_is_inbound(action)

def transaction_item_action_is_outbound(action):
    return _transaction.transaction_item_action_is_outbound(action)
TransactionItemReason_NONE = _transaction.TransactionItemReason_NONE
TransactionItemReason_DEPENDENCY = _transaction.TransactionItemReason_DEPENDENCY
TransactionItemReason_USER = _transaction.TransactionItemReason_USER
TransactionItemReason_CLEAN = _transaction.TransactionItemReason_CLEAN
TransactionItemReason_WEAK_DEPENDENCY = _transaction.TransactionItemReason_WEAK_DEPENDENCY
TransactionItemReason_GROUP = _transaction.TransactionItemReason_GROUP
TransactionItemReason_EXTERNAL_USER = _transaction.TransactionItemReason_EXTERNAL_USER

def transaction_item_reason_to_string(reason):
    return _transaction.transaction_item_reason_to_string(reason)

def transaction_item_reason_to_translated_string(reason):
    return _transaction.transaction_item_reason_to_translated_string(reason)

def transaction_item_reason_from_string(reason):
    return _transaction.transaction_item_reason_from_string(reason)

def transaction_item_reason_compare(lhs, rhs):
    r"""
    Compare transaction items and return:
    -1 if lhs < rhs
    1 if lhs > rhs
    0 if lhs == rhs
    Higher number means a better (or a stronger) reason.
    """
    return _transaction.transaction_item_reason_compare(lhs, rhs)

def __lt__(lhs, rhs):
    return _transaction.__lt__(lhs, rhs)

def __le__(lhs, rhs):
    return _transaction.__le__(lhs, rhs)

def __gt__(lhs, rhs):
    return _transaction.__gt__(lhs, rhs)

def __ge__(lhs, rhs):
    return _transaction.__ge__(lhs, rhs)
TransactionItemState_STARTED = _transaction.TransactionItemState_STARTED
TransactionItemState_OK = _transaction.TransactionItemState_OK
TransactionItemState_ERROR = _transaction.TransactionItemState_ERROR

def transaction_item_state_to_string(state):
    return _transaction.transaction_item_state_to_string(state)

def transaction_item_state_from_string(state):
    return _transaction.transaction_item_state_from_string(state)
class TransactionItem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def get_action(self):
        r"""Get action associated with the transaction item in the transaction"""
        return _transaction.TransactionItem_get_action(self)

    def get_reason(self):
        r"""Get reason of the action associated with the transaction item in the transaction"""
        return _transaction.TransactionItem_get_reason(self)

    def get_repoid(self):
        r"""Get transaction item repoid (text identifier of a repository)"""
        return _transaction.TransactionItem_get_repoid(self)

    def get_state(self):
        r"""Get transaction item state"""
        return _transaction.TransactionItem_get_state(self)
    __swig_destroy__ = _transaction.delete_TransactionItem

    def __init__(self, *args):
        _transaction.TransactionItem_swiginit(self, _transaction.new_TransactionItem(*args))

# Register TransactionItem in _transaction:
_transaction.TransactionItem_swigregister(TransactionItem)
class CompsGroup(TransactionItem):
    r"""
    CompsGroup contains a copy of important data from comps::CompsGroup that is used
    to perform comps transaction and then stored in the transaction (history) database.
    """

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

    def to_string(self):
        r"""Get string representation of the object, which equals to group_id"""
        return _transaction.CompsGroup_to_string(self)

    def get_package_types(self):
        r"""Get types of the packages to be installed with the group (related xml elements: `<comps><group><packagelist><packagereq type="VALUE" ...>`)"""
        return _transaction.CompsGroup_get_package_types(self)

    def __init__(self, *args):
        _transaction.CompsGroup_swiginit(self, _transaction.new_CompsGroup(*args))
    __swig_destroy__ = _transaction.delete_CompsGroup

# Register CompsGroup in _transaction:
_transaction.CompsGroup_swigregister(CompsGroup)
class CompsGroupPackage(object):
    r"""CompsGroupPackage represents a package associated with a comps group"""

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

    def __init__(self, *args):
        _transaction.CompsGroupPackage_swiginit(self, _transaction.new_CompsGroupPackage(*args))

# Register CompsGroupPackage in _transaction:
_transaction.CompsGroupPackage_swigregister(CompsGroupPackage)
class CompsEnvironment(TransactionItem):
    r"""
    CompsEnvironment contains a copy of important data from comps::CompsEnvironment that is used
    to perform comps transaction and then stored in the transaction (history) database.
    """

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

    def to_string(self):
        r"""Get string representation of the object, which equals to environment_id"""
        return _transaction.CompsEnvironment_to_string(self)

    def __init__(self, *args):
        _transaction.CompsEnvironment_swiginit(self, _transaction.new_CompsEnvironment(*args))
    __swig_destroy__ = _transaction.delete_CompsEnvironment

# Register CompsEnvironment in _transaction:
_transaction.CompsEnvironment_swigregister(CompsEnvironment)
class CompsEnvironmentGroup(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _transaction.delete_CompsEnvironmentGroup

    def __init__(self, *args):
        _transaction.CompsEnvironmentGroup_swiginit(self, _transaction.new_CompsEnvironmentGroup(*args))

# Register CompsEnvironmentGroup in _transaction:
_transaction.CompsEnvironmentGroup_swigregister(CompsEnvironmentGroup)
class Package(TransactionItem):
    r"""
    Package contains a copy of important data from rpm::Package that is used
    to perform rpm transaction and then stored in the transaction (history) database.
    """

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

    def get_name(self):
        r"""Get package name"""
        return _transaction.Package_get_name(self)

    def get_epoch(self):
        r"""Get package epoch"""
        return _transaction.Package_get_epoch(self)

    def get_release(self):
        r"""Get package release"""
        return _transaction.Package_get_release(self)

    def get_arch(self):
        r"""Get package arch"""
        return _transaction.Package_get_arch(self)

    def get_version(self):
        r"""Get package version"""
        return _transaction.Package_get_version(self)

    def to_string(self):
        r"""Get string representation of the object, which equals to package NEVRA"""
        return _transaction.Package_to_string(self)
    __swig_destroy__ = _transaction.delete_Package

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

# Register Package in _transaction:
_transaction.Package_swigregister(Package)
class TransactionHistory(object):
    r"""A class for working with transactions recorded in the transaction history database."""

    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):
        _transaction.TransactionHistory_swiginit(self, _transaction.new_TransactionHistory(*args))
    __swig_destroy__ = _transaction.delete_TransactionHistory

    def get_weak_ptr(self):
        return _transaction.TransactionHistory_get_weak_ptr(self)

    def list_transaction_ids(self):
        r"""
        Lists all transaction IDs from the transaction history database. The
        result is sorted in ascending order.

        :rtype: std::vector< int64_t,std::allocator< int64_t > >
        :return: The list of transaction IDs.
        """
        return _transaction.TransactionHistory_list_transaction_ids(self)

    def list_transactions(self, *args):
        r"""
        *Overload 1:*
        Lists transactions from the transaction history for transaction ids in `ids`.

        :type ids: std::vector< int64_t,std::allocator< int64_t > >
        :param ids: The ids to list.
        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: The listed transactions.

        |

        *Overload 2:*
        Lists transactions from the transaction history for transaction ids
        within the [start, end] range (inclusive).

        :type start: int
        :param start: The first id of the range to be listed.
        :type end: int
        :param end: The last id of the range to be listed.
        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: The listed transactions.
        """
        return _transaction.TransactionHistory_list_transactions(self, *args)

    def list_transactions_since(self, start):
        r"""
        Lists all transactions that are newer than the provided timestamp.

        :type start: int
        :param start: The point of time against which is compared the timestamp
                         of the end of the transaction.
        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: List of all transaction that ended after the timestamp.
        """
        return _transaction.TransactionHistory_list_transactions_since(self, start)

    def list_all_transactions(self):
        r"""
        Lists all transactions from the transaction history.

        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: The listed transactions.
        """
        return _transaction.TransactionHistory_list_all_transactions(self)

    def get_latest_transaction(self):
        r"""
        Returns the latest transaction.

        :rtype: :py:class:`Transaction`
        :return: The latest transaction.
        """
        return _transaction.TransactionHistory_get_latest_transaction(self)

    def get_base(self):
        r"""
        :rtype: libdnf5::BaseWeakPtr
        :return: The `Base` object to which this object belongs.
        Since: 5.0
        """
        return _transaction.TransactionHistory_get_base(self)

    def transaction_item_reason_at(self, name, arch, transaction_id_point):
        r"""
        Get reason for package specified by name and arch at a point in history
        specified by transaction id.

        :type name: string
        :param name: Name of rpm package
        :type arch: string
        :param arch: Arch of rpm package
        :type transaction_id_point: int
        :param transaction_id_point: Id of a history transaction (can be obtained from
                                        libdnf5::transaction::TransactionHistory)
        :rtype: int
        :return: Reason of the last transaction item before transaction_id_point that
                    has an rpm with matching name and arch.
        """
        return _transaction.TransactionHistory_transaction_item_reason_at(self, name, arch, transaction_id_point)

    def get_transaction_item_counts(self, transactions):
        r"""
        Get counts of transaction items for specified transactions.
        It gets the counts in a single db query.

        :type transactions: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :param transactions: Get counts for these transactions.

        :rtype: std::unordered_map< int64_t,int64_t >
        :return: Mapped transaction id -> count.
        """
        return _transaction.TransactionHistory_get_transaction_item_counts(self, transactions)

    def filter_transactions_by_pkg_names(self, transactions, pkg_names):
        r"""
        Filter out transactions that don't contain any rpm with matching name

        :type transactions: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :param transactions:     Vector of Transactions to filter
        :type pkg_names: std::vector< std::string,std::allocator< std::string > >
        :param pkg_names:        Vector of rpm package names to match
        """
        return _transaction.TransactionHistory_filter_transactions_by_pkg_names(self, transactions, pkg_names)

# Register TransactionHistory in _transaction:
_transaction.TransactionHistory_swigregister(TransactionHistory)
class TransactionHistoryWeakPtr(object):
    r"""
    WeakPtr is a "smart" pointer. It contains a pointer to resource and to guard of resource.
    WeakPtr pointer can be owner of the resource. However, the resource itself may depend on another resource.
    WeakPtr registers/unregisters itself at the guard of resource. And the resource guard invalidates
    the registered WeakPtrs when the resource is unusable (eg. its dependecny was released).
    Note on thread safety:
    It is safe to create, access and destroy WeakPtrs in multiple threads simultaneously.
    """

    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):
        _transaction.TransactionHistoryWeakPtr_swiginit(self, _transaction.new_TransactionHistoryWeakPtr(*args))
    __swig_destroy__ = _transaction.delete_TransactionHistoryWeakPtr

    def __deref__(self):
        r"""Provides access to the managed object. Generates exception if object is not valid."""
        return _transaction.TransactionHistoryWeakPtr___deref__(self)

    def get(self):
        r"""Returns a pointer to the managed object. Generates exception if object is not valid."""
        return _transaction.TransactionHistoryWeakPtr_get(self)

    def is_valid(self):
        r"""Checks if managed object is valid."""
        return _transaction.TransactionHistoryWeakPtr_is_valid(self)

    def has_same_guard(self, other):
        r"""Checks if the other WeakPtr instance has the same WeakPtrGuard."""
        return _transaction.TransactionHistoryWeakPtr_has_same_guard(self, other)

    def __ref__(self):
        return _transaction.TransactionHistoryWeakPtr___ref__(self)

    def __eq__(self, other):
        return _transaction.TransactionHistoryWeakPtr___eq__(self, other)

    def __ne__(self, other):
        return _transaction.TransactionHistoryWeakPtr___ne__(self, other)

    def __lt__(self, other):
        return _transaction.TransactionHistoryWeakPtr___lt__(self, other)

    def __gt__(self, other):
        return _transaction.TransactionHistoryWeakPtr___gt__(self, other)

    def __le__(self, other):
        return _transaction.TransactionHistoryWeakPtr___le__(self, other)

    def __ge__(self, other):
        return _transaction.TransactionHistoryWeakPtr___ge__(self, other)

    def __hash__(self):
        return _transaction.TransactionHistoryWeakPtr___hash__(self)

    def get_weak_ptr(self):
        return _transaction.TransactionHistoryWeakPtr_get_weak_ptr(self)

    def list_transaction_ids(self):
        r"""
        Lists all transaction IDs from the transaction history database. The
        result is sorted in ascending order.

        :rtype: std::vector< int64_t,std::allocator< int64_t > >
        :return: The list of transaction IDs.
        """
        return _transaction.TransactionHistoryWeakPtr_list_transaction_ids(self)

    def list_transactions(self, *args):
        r"""
        *Overload 1:*
        Lists transactions from the transaction history for transaction ids in `ids`.

        :type ids: std::vector< int64_t,std::allocator< int64_t > >
        :param ids: The ids to list.
        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: The listed transactions.

        |

        *Overload 2:*
        Lists transactions from the transaction history for transaction ids
        within the [start, end] range (inclusive).

        :type start: int
        :param start: The first id of the range to be listed.
        :type end: int
        :param end: The last id of the range to be listed.
        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: The listed transactions.
        """
        return _transaction.TransactionHistoryWeakPtr_list_transactions(self, *args)

    def list_transactions_since(self, start):
        r"""
        Lists all transactions that are newer than the provided timestamp.

        :type start: int
        :param start: The point of time against which is compared the timestamp
                         of the end of the transaction.
        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: List of all transaction that ended after the timestamp.
        """
        return _transaction.TransactionHistoryWeakPtr_list_transactions_since(self, start)

    def list_all_transactions(self):
        r"""
        Lists all transactions from the transaction history.

        :rtype: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :return: The listed transactions.
        """
        return _transaction.TransactionHistoryWeakPtr_list_all_transactions(self)

    def get_latest_transaction(self):
        r"""
        Returns the latest transaction.

        :rtype: :py:class:`Transaction`
        :return: The latest transaction.
        """
        return _transaction.TransactionHistoryWeakPtr_get_latest_transaction(self)

    def get_base(self):
        r"""
        :rtype: libdnf5::BaseWeakPtr
        :return: The `Base` object to which this object belongs.
        Since: 5.0
        """
        return _transaction.TransactionHistoryWeakPtr_get_base(self)

    def transaction_item_reason_at(self, name, arch, transaction_id_point):
        r"""
        Get reason for package specified by name and arch at a point in history
        specified by transaction id.

        :type name: string
        :param name: Name of rpm package
        :type arch: string
        :param arch: Arch of rpm package
        :type transaction_id_point: int
        :param transaction_id_point: Id of a history transaction (can be obtained from
                                        libdnf5::transaction::TransactionHistory)
        :rtype: int
        :return: Reason of the last transaction item before transaction_id_point that
                    has an rpm with matching name and arch.
        """
        return _transaction.TransactionHistoryWeakPtr_transaction_item_reason_at(self, name, arch, transaction_id_point)

    def get_transaction_item_counts(self, transactions):
        r"""
        Get counts of transaction items for specified transactions.
        It gets the counts in a single db query.

        :type transactions: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :param transactions: Get counts for these transactions.

        :rtype: std::unordered_map< int64_t,int64_t >
        :return: Mapped transaction id -> count.
        """
        return _transaction.TransactionHistoryWeakPtr_get_transaction_item_counts(self, transactions)

    def filter_transactions_by_pkg_names(self, transactions, pkg_names):
        r"""
        Filter out transactions that don't contain any rpm with matching name

        :type transactions: std::vector< libdnf5::transaction::Transaction,std::allocator< libdnf5::transaction::Transaction > >
        :param transactions:     Vector of Transactions to filter
        :type pkg_names: std::vector< std::string,std::allocator< std::string > >
        :param pkg_names:        Vector of rpm package names to match
        """
        return _transaction.TransactionHistoryWeakPtr_filter_transactions_by_pkg_names(self, transactions, pkg_names)

# Register TransactionHistoryWeakPtr in _transaction:
_transaction.TransactionHistoryWeakPtr_swigregister(TransactionHistoryWeakPtr)
TransactionState_STARTED = _transaction.TransactionState_STARTED
TransactionState_OK = _transaction.TransactionState_OK
TransactionState_ERROR = _transaction.TransactionState_ERROR

def transaction_state_to_string(state):
    return _transaction.transaction_state_to_string(state)

def transaction_state_to_translated_string(state):
    return _transaction.transaction_state_to_translated_string(state)

def transaction_state_from_string(state):
    return _transaction.transaction_state_from_string(state)
class Transaction(object):
    r"""
    Transaction holds information about a transaction.
    It contains transaction items such as packages, comps groups and environments.
    Transaction object are used to retrieve information about past transactions
    from the transaction history database as well as for performing a transaction
    to change packages on disk.
    """

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

    def __init__(self, *args):
        _transaction.Transaction_swiginit(self, _transaction.new_Transaction(*args))

    def __eq__(self, other):
        return _transaction.Transaction___eq__(self, other)

    def __lt__(self, other):
        return _transaction.Transaction___lt__(self, other)

    def __gt__(self, other):
        return _transaction.Transaction___gt__(self, other)

    def get_id(self):
        r"""
        Get Transaction database id (primary key)
        Return 0 if the id wasn't set yet
        """
        return _transaction.Transaction_get_id(self)

    def get_dt_start(self):
        r"""Get date and time of the transaction start"""
        return _transaction.Transaction_get_dt_start(self)

    def get_dt_end(self):
        r"""Get date and time of the transaction end"""
        return _transaction.Transaction_get_dt_end(self)

    def get_rpmdb_version_begin(self):
        r"""
        Get RPM database version before the transaction
        Format: `<rpm_count>`:`<sha1 of sorted SHA1HEADER fields of installed RPMs>`
        """
        return _transaction.Transaction_get_rpmdb_version_begin(self)

    def get_rpmdb_version_end(self):
        r"""
        Get RPM database version after the transaction
        Format: `<rpm_count>`:`<sha1 of sorted SHA1HEADER fields of installed RPMs>`
        """
        return _transaction.Transaction_get_rpmdb_version_end(self)

    def get_releasever(self):
        r"""Get $releasever variable value that was used during the transaction"""
        return _transaction.Transaction_get_releasever(self)

    def get_user_id(self):
        r"""Get UID of a user that started the transaction"""
        return _transaction.Transaction_get_user_id(self)

    def get_description(self):
        r"""Get the description of the transaction (e.g. the CLI command that was executed)"""
        return _transaction.Transaction_get_description(self)

    def get_comment(self):
        r"""Get a user-specified comment describing the transaction"""
        return _transaction.Transaction_get_comment(self)

    def get_state(self):
        r"""Get transaction state"""
        return _transaction.Transaction_get_state(self)

    def get_comps_environments(self):
        r"""Return all comps environments associated with the transaction"""
        return _transaction.Transaction_get_comps_environments(self)

    def get_comps_groups(self):
        r"""Return all comps groups associated with the transaction"""
        return _transaction.Transaction_get_comps_groups(self)

    def get_packages(self):
        r"""Return all rpm packages associated with the transaction"""
        return _transaction.Transaction_get_packages(self)

    def serialize(self):
        r"""
        Warning: This method is experimental/unstable and should not be relied on. It may be removed without warning
        Serialize the transaction into a json data format which can be later loaded
        into a `libdnf5::Goal` and replayed.
        """
        return _transaction.Transaction_serialize(self)

    def get_base(self):
        r"""
        :rtype: libdnf5::BaseWeakPtr
        :return: A `Base` object to which the transaction belongs.
        """
        return _transaction.Transaction_get_base(self)

# Register Transaction in _transaction:
_transaction.Transaction_swigregister(Transaction)
class VectorTransaction(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 _transaction.VectorTransaction_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __bool__(self):
        return _transaction.VectorTransaction___bool__(self)

    def __len__(self):
        return _transaction.VectorTransaction___len__(self)

    def __delitem__(self, *args):
        return _transaction.VectorTransaction___delitem__(self, *args)

    def __getitem__(self, *args):
        return _transaction.VectorTransaction___getitem__(self, *args)

    def __setitem__(self, *args):
        return _transaction.VectorTransaction___setitem__(self, *args)

    def pop(self):
        return _transaction.VectorTransaction_pop(self)

    def append(self, x):
        return _transaction.VectorTransaction_append(self, x)

    def empty(self):
        return _transaction.VectorTransaction_empty(self)

    def size(self):
        return _transaction.VectorTransaction_size(self)

    def swap(self, v):
        return _transaction.VectorTransaction_swap(self, v)

    def begin(self):
        return _transaction.VectorTransaction_begin(self)

    def end(self):
        return _transaction.VectorTransaction_end(self)

    def rbegin(self):
        return _transaction.VectorTransaction_rbegin(self)

    def rend(self):
        return _transaction.VectorTransaction_rend(self)

    def clear(self):
        return _transaction.VectorTransaction_clear(self)

    def get_allocator(self):
        return _transaction.VectorTransaction_get_allocator(self)

    def pop_back(self):
        return _transaction.VectorTransaction_pop_back(self)

    def erase(self, *args):
        return _transaction.VectorTransaction_erase(self, *args)

    def __init__(self, *args):
        _transaction.VectorTransaction_swiginit(self, _transaction.new_VectorTransaction(*args))

    def push_back(self, x):
        return _transaction.VectorTransaction_push_back(self, x)

    def front(self):
        return _transaction.VectorTransaction_front(self)

    def back(self):
        return _transaction.VectorTransaction_back(self)

    def assign(self, n, x):
        return _transaction.VectorTransaction_assign(self, n, x)

    def insert(self, *args):
        return _transaction.VectorTransaction_insert(self, *args)

    def reserve(self, n):
        return _transaction.VectorTransaction_reserve(self, n)

    def capacity(self):
        return _transaction.VectorTransaction_capacity(self)
    __swig_destroy__ = _transaction.delete_VectorTransaction

# Register VectorTransaction in _transaction:
_transaction.VectorTransaction_swigregister(VectorTransaction)
class VectorTransactionPackage(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 _transaction.VectorTransactionPackage_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __bool__(self):
        return _transaction.VectorTransactionPackage___bool__(self)

    def __len__(self):
        return _transaction.VectorTransactionPackage___len__(self)

    def __delitem__(self, *args):
        return _transaction.VectorTransactionPackage___delitem__(self, *args)

    def __getitem__(self, *args):
        return _transaction.VectorTransactionPackage___getitem__(self, *args)

    def __setitem__(self, *args):
        return _transaction.VectorTransactionPackage___setitem__(self, *args)

    def pop(self):
        return _transaction.VectorTransactionPackage_pop(self)

    def append(self, x):
        return _transaction.VectorTransactionPackage_append(self, x)

    def empty(self):
        return _transaction.VectorTransactionPackage_empty(self)

    def size(self):
        return _transaction.VectorTransactionPackage_size(self)

    def swap(self, v):
        return _transaction.VectorTransactionPackage_swap(self, v)

    def begin(self):
        return _transaction.VectorTransactionPackage_begin(self)

    def end(self):
        return _transaction.VectorTransactionPackage_end(self)

    def rbegin(self):
        return _transaction.VectorTransactionPackage_rbegin(self)

    def rend(self):
        return _transaction.VectorTransactionPackage_rend(self)

    def clear(self):
        return _transaction.VectorTransactionPackage_clear(self)

    def get_allocator(self):
        return _transaction.VectorTransactionPackage_get_allocator(self)

    def pop_back(self):
        return _transaction.VectorTransactionPackage_pop_back(self)

    def erase(self, *args):
        return _transaction.VectorTransactionPackage_erase(self, *args)

    def __init__(self, *args):
        _transaction.VectorTransactionPackage_swiginit(self, _transaction.new_VectorTransactionPackage(*args))

    def push_back(self, x):
        return _transaction.VectorTransactionPackage_push_back(self, x)

    def front(self):
        return _transaction.VectorTransactionPackage_front(self)

    def back(self):
        return _transaction.VectorTransactionPackage_back(self)

    def assign(self, n, x):
        return _transaction.VectorTransactionPackage_assign(self, n, x)

    def insert(self, *args):
        return _transaction.VectorTransactionPackage_insert(self, *args)

    def reserve(self, n):
        return _transaction.VectorTransactionPackage_reserve(self, n)

    def capacity(self):
        return _transaction.VectorTransactionPackage_capacity(self)
    __swig_destroy__ = _transaction.delete_VectorTransactionPackage

# Register VectorTransactionPackage in _transaction:
_transaction.VectorTransactionPackage_swigregister(VectorTransactionPackage)

