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

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

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 gncSplitGetGUID(x):
    r"""gncSplitGetGUID(Split * x) -> GncGUID"""
    return _gnucash_core_c.gncSplitGetGUID(x)

def gncTransGetGUID(x):
    r"""gncTransGetGUID(Transaction * x) -> GncGUID"""
    return _gnucash_core_c.gncTransGetGUID(x)

def gncAccountGetGUID(x):
    r"""gncAccountGetGUID(Account * x) -> GncGUID"""
    return _gnucash_core_c.gncAccountGetGUID(x)

def gnc_split_get_type():
    r"""gnc_split_get_type() -> GType"""
    return _gnucash_core_c.gnc_split_get_type()
CREC = _gnucash_core_c.CREC

YREC = _gnucash_core_c.YREC

FREC = _gnucash_core_c.FREC

NREC = _gnucash_core_c.NREC

VREC = _gnucash_core_c.VREC


def xaccSplitConvertAmount(split, account):
    r"""xaccSplitConvertAmount(Split const * split, Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitConvertAmount(split, account)

def xaccMallocSplit(book):
    r"""xaccMallocSplit(QofBook * book) -> Split *"""
    return _gnucash_core_c.xaccMallocSplit(book)

def xaccSplitReinit(split):
    r"""xaccSplitReinit(Split * split)"""
    return _gnucash_core_c.xaccSplitReinit(split)

def xaccSplitDestroy(split):
    r"""xaccSplitDestroy(Split * split) -> gboolean"""
    return _gnucash_core_c.xaccSplitDestroy(split)

def xaccSplitCopyOnto(from_split, to_split):
    r"""xaccSplitCopyOnto(Split const * from_split, Split * to_split)"""
    return _gnucash_core_c.xaccSplitCopyOnto(from_split, to_split)

def xaccSplitGetBook(split):
    r"""xaccSplitGetBook(Split const * split) -> QofBook *"""
    return _gnucash_core_c.xaccSplitGetBook(split)

def xaccSplitGetAccount(split):
    r"""xaccSplitGetAccount(Split const * split) -> Account *"""
    return _gnucash_core_c.xaccSplitGetAccount(split)

def xaccSplitSetAccount(s, acc):
    r"""xaccSplitSetAccount(Split * s, Account * acc)"""
    return _gnucash_core_c.xaccSplitSetAccount(s, acc)

def xaccSplitGetParent(split):
    r"""xaccSplitGetParent(Split const * split) -> Transaction *"""
    return _gnucash_core_c.xaccSplitGetParent(split)

def xaccSplitSetParent(split, trans):
    r"""xaccSplitSetParent(Split * split, Transaction * trans)"""
    return _gnucash_core_c.xaccSplitSetParent(split, trans)

def xaccSplitGetLot(split):
    r"""xaccSplitGetLot(Split const * split) -> GNCLot *"""
    return _gnucash_core_c.xaccSplitGetLot(split)

def xaccSplitSetLot(split, lot):
    r"""xaccSplitSetLot(Split * split, GNCLot * lot)"""
    return _gnucash_core_c.xaccSplitSetLot(split, lot)

def xaccSplitSetMemo(split, memo):
    r"""xaccSplitSetMemo(Split * split, char const * memo)"""
    return _gnucash_core_c.xaccSplitSetMemo(split, memo)

def xaccSplitGetMemo(split):
    r"""xaccSplitGetMemo(Split const * split) -> char const *"""
    return _gnucash_core_c.xaccSplitGetMemo(split)

def xaccSplitSetOnlineID(split, id):
    r"""xaccSplitSetOnlineID(Split * split, char const * id)"""
    return _gnucash_core_c.xaccSplitSetOnlineID(split, id)

def xaccSplitGetOnlineID(split):
    r"""xaccSplitGetOnlineID(Split const * split) -> char const *"""
    return _gnucash_core_c.xaccSplitGetOnlineID(split)

def xaccSplitHasOnlineID(split):
    r"""xaccSplitHasOnlineID(Split const * split) -> gboolean"""
    return _gnucash_core_c.xaccSplitHasOnlineID(split)

def xaccSplitSetAction(split, action):
    r"""xaccSplitSetAction(Split * split, char const * action)"""
    return _gnucash_core_c.xaccSplitSetAction(split, action)

def xaccSplitGetAction(split):
    r"""xaccSplitGetAction(Split const * split) -> char const *"""
    return _gnucash_core_c.xaccSplitGetAction(split)

def xaccSplitSetReconcile(split, reconciled_flag):
    r"""xaccSplitSetReconcile(Split * split, char reconciled_flag)"""
    return _gnucash_core_c.xaccSplitSetReconcile(split, reconciled_flag)

def xaccSplitGetReconcile(split):
    r"""xaccSplitGetReconcile(Split const * split) -> char"""
    return _gnucash_core_c.xaccSplitGetReconcile(split)

def xaccSplitSetDateReconciledSecs(split, time):
    r"""xaccSplitSetDateReconciledSecs(Split * split, time64 time)"""
    return _gnucash_core_c.xaccSplitSetDateReconciledSecs(split, time)

def xaccSplitGetDateReconciled(split):
    r"""xaccSplitGetDateReconciled(Split const * split) -> time64"""
    return _gnucash_core_c.xaccSplitGetDateReconciled(split)

def xaccSplitSetAmount(split, amount):
    r"""xaccSplitSetAmount(Split * split, _gnc_numeric amount)"""
    return _gnucash_core_c.xaccSplitSetAmount(split, amount)

def xaccSplitGetAmount(split):
    r"""xaccSplitGetAmount(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetAmount(split)

def xaccSplitSetValue(split, value):
    r"""xaccSplitSetValue(Split * split, _gnc_numeric value)"""
    return _gnucash_core_c.xaccSplitSetValue(split, value)

def xaccSplitGetValue(split):
    r"""xaccSplitGetValue(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetValue(split)

def xaccSplitSetSharePriceAndAmount(split, price, amount):
    r"""xaccSplitSetSharePriceAndAmount(Split * split, _gnc_numeric price, _gnc_numeric amount)"""
    return _gnucash_core_c.xaccSplitSetSharePriceAndAmount(split, price, amount)

def xaccSplitGetSharePrice(split):
    r"""xaccSplitGetSharePrice(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetSharePrice(split)

def xaccSplitSetBaseValue(split, value, base_currency):
    r"""xaccSplitSetBaseValue(Split * split, _gnc_numeric value, gnc_commodity const * base_currency)"""
    return _gnucash_core_c.xaccSplitSetBaseValue(split, value, base_currency)

def xaccSplitGetBaseValue(split, base_currency):
    r"""xaccSplitGetBaseValue(Split const * split, gnc_commodity const * base_currency) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetBaseValue(split, base_currency)

def xaccSplitGetBalance(split):
    r"""xaccSplitGetBalance(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetBalance(split)

def xaccSplitGetNoclosingBalance(split):
    r"""xaccSplitGetNoclosingBalance(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetNoclosingBalance(split)

def xaccSplitGetClearedBalance(split):
    r"""xaccSplitGetClearedBalance(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetClearedBalance(split)

def xaccSplitGetReconciledBalance(split):
    r"""xaccSplitGetReconciledBalance(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetReconciledBalance(split)

def xaccSplitEqual(sa, sb, check_guids, check_balances, check_txn_splits):
    r"""xaccSplitEqual(Split const * sa, Split const * sb, gboolean check_guids, gboolean check_balances, gboolean check_txn_splits) -> gboolean"""
    return _gnucash_core_c.xaccSplitEqual(sa, sb, check_guids, check_balances, check_txn_splits)

def xaccSplitLookup(guid, book):
    r"""xaccSplitLookup(GncGUID guid, QofBook * book) -> Split *"""
    return _gnucash_core_c.xaccSplitLookup(guid, book)

def xaccSplitAddPeerSplit(split, other_split, timestamp):
    r"""xaccSplitAddPeerSplit(Split * split, Split const * other_split, time64 const timestamp)"""
    return _gnucash_core_c.xaccSplitAddPeerSplit(split, other_split, timestamp)

def xaccSplitHasPeers(split):
    r"""xaccSplitHasPeers(Split const * split) -> gboolean"""
    return _gnucash_core_c.xaccSplitHasPeers(split)

def xaccSplitIsPeerSplit(split, other_split):
    r"""xaccSplitIsPeerSplit(Split const * split, Split const * other_split) -> gboolean"""
    return _gnucash_core_c.xaccSplitIsPeerSplit(split, other_split)

def xaccSplitRemovePeerSplit(split, other_split):
    r"""xaccSplitRemovePeerSplit(Split * split, Split const * other_split)"""
    return _gnucash_core_c.xaccSplitRemovePeerSplit(split, other_split)

def xaccSplitMergePeerSplits(split, other_split):
    r"""xaccSplitMergePeerSplits(Split * split, Split const * other_split)"""
    return _gnucash_core_c.xaccSplitMergePeerSplits(split, other_split)

def xaccSplitGetOtherSplit(split):
    r"""xaccSplitGetOtherSplit(Split const * split) -> Split *"""
    return _gnucash_core_c.xaccSplitGetOtherSplit(split)

def xaccSplitGetType(s):
    r"""xaccSplitGetType(Split const * s) -> char const *"""
    return _gnucash_core_c.xaccSplitGetType(s)

def xaccSplitMakeStockSplit(s):
    r"""xaccSplitMakeStockSplit(Split * s)"""
    return _gnucash_core_c.xaccSplitMakeStockSplit(s)

def xaccSplitOrder(sa, sb):
    r"""xaccSplitOrder(Split const * sa, Split const * sb) -> gint"""
    return _gnucash_core_c.xaccSplitOrder(sa, sb)

def xaccSplitOrderDateOnly(sa, sb):
    r"""xaccSplitOrderDateOnly(Split const * sa, Split const * sb) -> gint"""
    return _gnucash_core_c.xaccSplitOrderDateOnly(sa, sb)

def xaccSplitCompareAccountFullNames(sa, sb):
    r"""xaccSplitCompareAccountFullNames(Split const * sa, Split const * sb) -> int"""
    return _gnucash_core_c.xaccSplitCompareAccountFullNames(sa, sb)

def xaccSplitCompareAccountCodes(sa, sb):
    r"""xaccSplitCompareAccountCodes(Split const * sa, Split const * sb) -> int"""
    return _gnucash_core_c.xaccSplitCompareAccountCodes(sa, sb)

def xaccSplitCompareOtherAccountFullNames(sa, sb):
    r"""xaccSplitCompareOtherAccountFullNames(Split const * sa, Split const * sb) -> int"""
    return _gnucash_core_c.xaccSplitCompareOtherAccountFullNames(sa, sb)

def xaccSplitCompareOtherAccountCodes(sa, sb):
    r"""xaccSplitCompareOtherAccountCodes(Split const * sa, Split const * sb) -> int"""
    return _gnucash_core_c.xaccSplitCompareOtherAccountCodes(sa, sb)

def xaccSplitGetCorrAccountFullName(sa):
    r"""xaccSplitGetCorrAccountFullName(Split const * sa) -> char *"""
    return _gnucash_core_c.xaccSplitGetCorrAccountFullName(sa)

def xaccSplitGetCorrAccountName(sa):
    r"""xaccSplitGetCorrAccountName(Split const * sa) -> char const *"""
    return _gnucash_core_c.xaccSplitGetCorrAccountName(sa)

def xaccSplitGetCorrAccountCode(sa):
    r"""xaccSplitGetCorrAccountCode(Split const * sa) -> char const *"""
    return _gnucash_core_c.xaccSplitGetCorrAccountCode(sa)

def xaccSplitSetSharePrice(split, price):
    r"""xaccSplitSetSharePrice(Split * split, _gnc_numeric price)"""
    return _gnucash_core_c.xaccSplitSetSharePrice(split, price)

def xaccSplitVoidFormerAmount(split):
    r"""xaccSplitVoidFormerAmount(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitVoidFormerAmount(split)

def xaccSplitVoidFormerValue(split):
    r"""xaccSplitVoidFormerValue(Split const * split) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitVoidFormerValue(split)
SPLIT_DATE_RECONCILED = _gnucash_core_c.SPLIT_DATE_RECONCILED

SPLIT_BALANCE = _gnucash_core_c.SPLIT_BALANCE

SPLIT_CLEARED_BALANCE = _gnucash_core_c.SPLIT_CLEARED_BALANCE

SPLIT_RECONCILED_BALANCE = _gnucash_core_c.SPLIT_RECONCILED_BALANCE

SPLIT_MEMO = _gnucash_core_c.SPLIT_MEMO

SPLIT_ACTION = _gnucash_core_c.SPLIT_ACTION

SPLIT_RECONCILE = _gnucash_core_c.SPLIT_RECONCILE

SPLIT_AMOUNT = _gnucash_core_c.SPLIT_AMOUNT

SPLIT_SHARE_PRICE = _gnucash_core_c.SPLIT_SHARE_PRICE

SPLIT_VALUE = _gnucash_core_c.SPLIT_VALUE

SPLIT_TYPE = _gnucash_core_c.SPLIT_TYPE

SPLIT_VOIDED_AMOUNT = _gnucash_core_c.SPLIT_VOIDED_AMOUNT

SPLIT_VOIDED_VALUE = _gnucash_core_c.SPLIT_VOIDED_VALUE

SPLIT_LOT = _gnucash_core_c.SPLIT_LOT

SPLIT_TRANS = _gnucash_core_c.SPLIT_TRANS

SPLIT_ACCOUNT = _gnucash_core_c.SPLIT_ACCOUNT

SPLIT_ACCOUNT_GUID = _gnucash_core_c.SPLIT_ACCOUNT_GUID

SPLIT_ACCT_FULLNAME = _gnucash_core_c.SPLIT_ACCT_FULLNAME

SPLIT_CORR_ACCT_NAME = _gnucash_core_c.SPLIT_CORR_ACCT_NAME

SPLIT_CORR_ACCT_CODE = _gnucash_core_c.SPLIT_CORR_ACCT_CODE


def gnc_account_get_children(account):
    r"""gnc_account_get_children(Account const * account) -> AccountList *"""
    return _gnucash_core_c.gnc_account_get_children(account)

def gnc_account_get_children_sorted(account):
    r"""gnc_account_get_children_sorted(Account const * account) -> AccountList *"""
    return _gnucash_core_c.gnc_account_get_children_sorted(account)

def gnc_account_get_descendants(account):
    r"""gnc_account_get_descendants(Account const * account) -> AccountList *"""
    return _gnucash_core_c.gnc_account_get_descendants(account)

def gnc_account_get_descendants_sorted(account):
    r"""gnc_account_get_descendants_sorted(Account const * account) -> AccountList *"""
    return _gnucash_core_c.gnc_account_get_descendants_sorted(account)
class AccountClass(object):
    r"""Proxy of C AccountClass struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    parent_class = property(_gnucash_core_c.AccountClass_parent_class_get, _gnucash_core_c.AccountClass_parent_class_set, doc=r"""parent_class : QofInstanceClass""")

    def __init__(self):
        r"""__init__(AccountClass self) -> AccountClass"""
        _gnucash_core_c.AccountClass_swiginit(self, _gnucash_core_c.new_AccountClass())
    __swig_destroy__ = _gnucash_core_c.delete_AccountClass

# Register AccountClass in _gnucash_core_c:
_gnucash_core_c.AccountClass_swigregister(AccountClass)

def gnc_account_get_type():
    r"""gnc_account_get_type() -> GType"""
    return _gnucash_core_c.gnc_account_get_type()
ACCT_TYPE_INVALID = _gnucash_core_c.ACCT_TYPE_INVALID

ACCT_TYPE_NONE = _gnucash_core_c.ACCT_TYPE_NONE

ACCT_TYPE_BANK = _gnucash_core_c.ACCT_TYPE_BANK

ACCT_TYPE_CASH = _gnucash_core_c.ACCT_TYPE_CASH

ACCT_TYPE_CREDIT = _gnucash_core_c.ACCT_TYPE_CREDIT

ACCT_TYPE_ASSET = _gnucash_core_c.ACCT_TYPE_ASSET

ACCT_TYPE_LIABILITY = _gnucash_core_c.ACCT_TYPE_LIABILITY

ACCT_TYPE_STOCK = _gnucash_core_c.ACCT_TYPE_STOCK

ACCT_TYPE_MUTUAL = _gnucash_core_c.ACCT_TYPE_MUTUAL

ACCT_TYPE_CURRENCY = _gnucash_core_c.ACCT_TYPE_CURRENCY

ACCT_TYPE_INCOME = _gnucash_core_c.ACCT_TYPE_INCOME

ACCT_TYPE_EXPENSE = _gnucash_core_c.ACCT_TYPE_EXPENSE

ACCT_TYPE_EQUITY = _gnucash_core_c.ACCT_TYPE_EQUITY

ACCT_TYPE_RECEIVABLE = _gnucash_core_c.ACCT_TYPE_RECEIVABLE

ACCT_TYPE_PAYABLE = _gnucash_core_c.ACCT_TYPE_PAYABLE

ACCT_TYPE_ROOT = _gnucash_core_c.ACCT_TYPE_ROOT

ACCT_TYPE_TRADING = _gnucash_core_c.ACCT_TYPE_TRADING

NUM_ACCOUNT_TYPES = _gnucash_core_c.NUM_ACCOUNT_TYPES

ACCT_TYPE_CHECKING = _gnucash_core_c.ACCT_TYPE_CHECKING

ACCT_TYPE_SAVINGS = _gnucash_core_c.ACCT_TYPE_SAVINGS

ACCT_TYPE_MONEYMRKT = _gnucash_core_c.ACCT_TYPE_MONEYMRKT

ACCT_TYPE_CREDITLINE = _gnucash_core_c.ACCT_TYPE_CREDITLINE

ACCT_TYPE_LAST = _gnucash_core_c.ACCT_TYPE_LAST


def xaccMallocAccount(book):
    r"""xaccMallocAccount(QofBook * book) -> Account *"""
    return _gnucash_core_c.xaccMallocAccount(book)

def gnc_account_create_root(book):
    r"""gnc_account_create_root(QofBook * book) -> Account *"""
    return _gnucash_core_c.gnc_account_create_root(book)

def xaccCloneAccount(source, book):
    r"""xaccCloneAccount(Account const * source, QofBook * book) -> Account *"""
    return _gnucash_core_c.xaccCloneAccount(source, book)

def xaccAccountBeginEdit(account):
    r"""xaccAccountBeginEdit(Account * account)"""
    return _gnucash_core_c.xaccAccountBeginEdit(account)

def xaccAccountCommitEdit(account):
    r"""xaccAccountCommitEdit(Account * account)"""
    return _gnucash_core_c.xaccAccountCommitEdit(account)

def xaccAccountDestroy(account):
    r"""xaccAccountDestroy(Account * account)"""
    return _gnucash_core_c.xaccAccountDestroy(account)

def xaccAccountDestroyAllTransactions(acc):
    r"""xaccAccountDestroyAllTransactions(Account * acc)"""
    return _gnucash_core_c.xaccAccountDestroyAllTransactions(acc)

def xaccAccountEqual(a, b, check_guids):
    r"""xaccAccountEqual(Account const * a, Account const * b, gboolean check_guids) -> gboolean"""
    return _gnucash_core_c.xaccAccountEqual(a, b, check_guids)

def xaccAccountOrder(account_1, account_2):
    r"""xaccAccountOrder(Account const * account_1, Account const * account_2) -> int"""
    return _gnucash_core_c.xaccAccountOrder(account_1, account_2)

def gnc_get_account_separator_string():
    r"""gnc_get_account_separator_string() -> gchar const *"""
    return _gnucash_core_c.gnc_get_account_separator_string()

def gnc_get_account_separator():
    r"""gnc_get_account_separator() -> gunichar"""
    return _gnucash_core_c.gnc_get_account_separator()

def gnc_set_account_separator(separator):
    r"""gnc_set_account_separator(gchar const * separator)"""
    return _gnucash_core_c.gnc_set_account_separator(separator)

def gnc_book_get_root_account(book):
    r"""gnc_book_get_root_account(QofBook * book) -> Account *"""
    return _gnucash_core_c.gnc_book_get_root_account(book)

def gnc_book_set_root_account(book, root):
    r"""gnc_book_set_root_account(QofBook * book, Account * root)"""
    return _gnucash_core_c.gnc_book_set_root_account(book, root)

def xaccAccountLookup(guid, book):
    r"""xaccAccountLookup(GncGUID guid, QofBook * book) -> Account *"""
    return _gnucash_core_c.xaccAccountLookup(guid, book)

def gnc_account_and_descendants_empty(acc):
    r"""gnc_account_and_descendants_empty(Account * acc) -> gboolean"""
    return _gnucash_core_c.gnc_account_and_descendants_empty(acc)

def gnc_account_name_violations_errmsg(separator, invalid_account_names):
    r"""gnc_account_name_violations_errmsg(gchar const * separator, GList * invalid_account_names) -> gchar *"""
    return _gnucash_core_c.gnc_account_name_violations_errmsg(separator, invalid_account_names)

def gnc_account_list_name_violations(book, separator):
    r"""gnc_account_list_name_violations(QofBook * book, gchar const * separator) -> GList *"""
    return _gnucash_core_c.gnc_account_list_name_violations(book, separator)

def gnc_account_get_book(account):
    r"""gnc_account_get_book(Account const * account) -> QofBook *"""
    return _gnucash_core_c.gnc_account_get_book(account)

def xaccAccountSetType(account, arg2):
    r"""xaccAccountSetType(Account * account, GNCAccountType arg2)"""
    return _gnucash_core_c.xaccAccountSetType(account, arg2)

def xaccAccountSetName(account, name):
    r"""xaccAccountSetName(Account * account, char const * name)"""
    return _gnucash_core_c.xaccAccountSetName(account, name)

def xaccAccountSetCode(account, code):
    r"""xaccAccountSetCode(Account * account, char const * code)"""
    return _gnucash_core_c.xaccAccountSetCode(account, code)

def xaccAccountSetDescription(account, desc):
    r"""xaccAccountSetDescription(Account * account, char const * desc)"""
    return _gnucash_core_c.xaccAccountSetDescription(account, desc)

def xaccAccountSetColor(account, color):
    r"""xaccAccountSetColor(Account * account, char const * color)"""
    return _gnucash_core_c.xaccAccountSetColor(account, color)

def xaccAccountSetFilter(account, filter):
    r"""xaccAccountSetFilter(Account * account, char const * filter)"""
    return _gnucash_core_c.xaccAccountSetFilter(account, filter)

def xaccAccountSetSortOrder(account, sortorder):
    r"""xaccAccountSetSortOrder(Account * account, char const * sortorder)"""
    return _gnucash_core_c.xaccAccountSetSortOrder(account, sortorder)

def xaccAccountSetSortReversed(account, sortreversed):
    r"""xaccAccountSetSortReversed(Account * account, gboolean sortreversed)"""
    return _gnucash_core_c.xaccAccountSetSortReversed(account, sortreversed)

def xaccAccountSetNotes(account, notes):
    r"""xaccAccountSetNotes(Account * account, char const * notes)"""
    return _gnucash_core_c.xaccAccountSetNotes(account, notes)

def xaccAccountSetOnlineID(account, id):
    r"""xaccAccountSetOnlineID(Account * account, char const * id)"""
    return _gnucash_core_c.xaccAccountSetOnlineID(account, id)

def xaccAccountSetAssociatedAccount(acc, tag, assoc_acct):
    r"""xaccAccountSetAssociatedAccount(Account * acc, char const * tag, Account const * assoc_acct)"""
    return _gnucash_core_c.xaccAccountSetAssociatedAccount(acc, tag, assoc_acct)

def xaccAccountSetLastNum(account, num):
    r"""xaccAccountSetLastNum(Account * account, char const * num)"""
    return _gnucash_core_c.xaccAccountSetLastNum(account, num)

def gnc_account_set_policy(account, policy):
    r"""gnc_account_set_policy(Account * account, GNCPolicy * policy)"""
    return _gnucash_core_c.gnc_account_set_policy(account, policy)

def xaccAccountGetType(account):
    r"""xaccAccountGetType(Account const * account) -> GNCAccountType"""
    return _gnucash_core_c.xaccAccountGetType(account)

def xaccAccountIsPriced(acc):
    r"""xaccAccountIsPriced(Account const * acc) -> gboolean"""
    return _gnucash_core_c.xaccAccountIsPriced(acc)

def gnc_account_set_start_balance(acc, start_baln):
    r"""gnc_account_set_start_balance(Account * acc, _gnc_numeric start_baln)"""
    return _gnucash_core_c.gnc_account_set_start_balance(acc, start_baln)

def gnc_account_set_start_cleared_balance(acc, start_baln):
    r"""gnc_account_set_start_cleared_balance(Account * acc, _gnc_numeric start_baln)"""
    return _gnucash_core_c.gnc_account_set_start_cleared_balance(acc, start_baln)

def gnc_account_set_start_reconciled_balance(acc, start_baln):
    r"""gnc_account_set_start_reconciled_balance(Account * acc, _gnc_numeric start_baln)"""
    return _gnucash_core_c.gnc_account_set_start_reconciled_balance(acc, start_baln)

def gnc_account_set_balance_dirty(acc):
    r"""gnc_account_set_balance_dirty(Account * acc)"""
    return _gnucash_core_c.gnc_account_set_balance_dirty(acc)

def gnc_account_set_sort_dirty(acc):
    r"""gnc_account_set_sort_dirty(Account * acc)"""
    return _gnucash_core_c.gnc_account_set_sort_dirty(acc)

def gnc_account_set_defer_bal_computation(acc, defer):
    r"""gnc_account_set_defer_bal_computation(Account * acc, gboolean defer)"""
    return _gnucash_core_c.gnc_account_set_defer_bal_computation(acc, defer)

def gnc_account_insert_split(acc, s):
    r"""gnc_account_insert_split(Account * acc, Split * s) -> gboolean"""
    return _gnucash_core_c.gnc_account_insert_split(acc, s)

def gnc_account_remove_split(acc, s):
    r"""gnc_account_remove_split(Account * acc, Split * s) -> gboolean"""
    return _gnucash_core_c.gnc_account_remove_split(acc, s)

def xaccAccountGetName(account):
    r"""xaccAccountGetName(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetName(account)

def xaccAccountGetCode(account):
    r"""xaccAccountGetCode(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetCode(account)

def xaccAccountGetDescription(account):
    r"""xaccAccountGetDescription(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetDescription(account)

def xaccAccountGetColor(account):
    r"""xaccAccountGetColor(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetColor(account)

def xaccAccountGetFilter(account):
    r"""xaccAccountGetFilter(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetFilter(account)

def xaccAccountGetSortOrder(account):
    r"""xaccAccountGetSortOrder(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetSortOrder(account)

def xaccAccountGetSortReversed(account):
    r"""xaccAccountGetSortReversed(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetSortReversed(account)

def xaccAccountGetNotes(account):
    r"""xaccAccountGetNotes(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetNotes(account)

def xaccAccountGetOnlineID(account):
    r"""xaccAccountGetOnlineID(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetOnlineID(account)

def xaccAccountGetAssociatedAccount(acc, tag):
    r"""xaccAccountGetAssociatedAccount(Account const * acc, char const * tag) -> Account *"""
    return _gnucash_core_c.xaccAccountGetAssociatedAccount(acc, tag)

def xaccAccountGetLastNum(account):
    r"""xaccAccountGetLastNum(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetLastNum(account)

def gnc_account_get_policy(account):
    r"""gnc_account_get_policy(Account * account) -> GNCPolicy *"""
    return _gnucash_core_c.gnc_account_get_policy(account)

def gnc_account_get_defer_bal_computation(acc):
    r"""gnc_account_get_defer_bal_computation(Account * acc) -> gboolean"""
    return _gnucash_core_c.gnc_account_get_defer_bal_computation(acc)

def xaccAccountRecomputeBalance(arg1):
    r"""xaccAccountRecomputeBalance(Account * arg1)"""
    return _gnucash_core_c.xaccAccountRecomputeBalance(arg1)

def xaccAccountSortSplits(acc, force):
    r"""xaccAccountSortSplits(Account * acc, gboolean force)"""
    return _gnucash_core_c.xaccAccountSortSplits(acc, force)

def gnc_account_get_full_name(account):
    r"""gnc_account_get_full_name(Account const * account) -> gchar *"""
    return _gnucash_core_c.gnc_account_get_full_name(account)

def xaccAccountGainsAccount(acc, curr):
    r"""xaccAccountGainsAccount(Account * acc, gnc_commodity * curr) -> Account *"""
    return _gnucash_core_c.xaccAccountGainsAccount(acc, curr)

def dxaccAccountSetPriceSrc(account, src):
    r"""dxaccAccountSetPriceSrc(Account * account, char const * src)"""
    return _gnucash_core_c.dxaccAccountSetPriceSrc(account, src)

def dxaccAccountGetPriceSrc(account):
    r"""dxaccAccountGetPriceSrc(Account const * account) -> char const *"""
    return _gnucash_core_c.dxaccAccountGetPriceSrc(account)

def xaccAccountSetCommodity(account, comm):
    r"""xaccAccountSetCommodity(Account * account, gnc_commodity * comm)"""
    return _gnucash_core_c.xaccAccountSetCommodity(account, comm)

def xaccAccountGetCommodity(account):
    r"""xaccAccountGetCommodity(Account const * account) -> gnc_commodity *"""
    return _gnucash_core_c.xaccAccountGetCommodity(account)

def gnc_account_get_currency_or_parent(account):
    r"""gnc_account_get_currency_or_parent(Account const * account) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_account_get_currency_or_parent(account)

def xaccAccountGetCommoditySCU(account):
    r"""xaccAccountGetCommoditySCU(Account const * account) -> int"""
    return _gnucash_core_c.xaccAccountGetCommoditySCU(account)

def xaccAccountGetCommoditySCUi(account):
    r"""xaccAccountGetCommoditySCUi(Account const * account) -> int"""
    return _gnucash_core_c.xaccAccountGetCommoditySCUi(account)

def xaccAccountSetCommoditySCU(account, frac):
    r"""xaccAccountSetCommoditySCU(Account * account, int frac)"""
    return _gnucash_core_c.xaccAccountSetCommoditySCU(account, frac)

def xaccAccountSetNonStdSCU(account, flag):
    r"""xaccAccountSetNonStdSCU(Account * account, gboolean flag)"""
    return _gnucash_core_c.xaccAccountSetNonStdSCU(account, flag)

def xaccAccountGetNonStdSCU(account):
    r"""xaccAccountGetNonStdSCU(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetNonStdSCU(account)

def xaccAccountGetBalance(account):
    r"""xaccAccountGetBalance(Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetBalance(account)

def xaccAccountGetClearedBalance(account):
    r"""xaccAccountGetClearedBalance(Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetClearedBalance(account)

def xaccAccountGetReconciledBalance(account):
    r"""xaccAccountGetReconciledBalance(Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetReconciledBalance(account)

def xaccAccountGetPresentBalance(account):
    r"""xaccAccountGetPresentBalance(Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetPresentBalance(account)

def xaccAccountGetProjectedMinimumBalance(account):
    r"""xaccAccountGetProjectedMinimumBalance(Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetProjectedMinimumBalance(account)

def xaccAccountGetBalanceAsOfDate(account, date):
    r"""xaccAccountGetBalanceAsOfDate(Account * account, time64 date) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetBalanceAsOfDate(account, date)

def xaccAccountGetReconciledBalanceAsOfDate(account, date):
    r"""xaccAccountGetReconciledBalanceAsOfDate(Account * account, time64 date) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetReconciledBalanceAsOfDate(account, date)

def xaccAccountConvertBalanceToCurrency(account, balance, balance_currency, new_currency):
    r"""xaccAccountConvertBalanceToCurrency(Account const * account, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountConvertBalanceToCurrency(account, balance, balance_currency, new_currency)

def xaccAccountConvertBalanceToCurrencyAsOfDate(account, balance, balance_currency, new_currency, date):
    r"""xaccAccountConvertBalanceToCurrencyAsOfDate(Account const * account, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency, time64 date) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountConvertBalanceToCurrencyAsOfDate(account, balance, balance_currency, new_currency, date)

def xaccAccountGetBalanceInCurrency(account, report_commodity, include_children):
    r"""xaccAccountGetBalanceInCurrency(Account const * account, gnc_commodity const * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetBalanceInCurrency(account, report_commodity, include_children)

def xaccAccountGetClearedBalanceInCurrency(account, report_commodity, include_children):
    r"""xaccAccountGetClearedBalanceInCurrency(Account const * account, gnc_commodity const * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetClearedBalanceInCurrency(account, report_commodity, include_children)

def xaccAccountGetReconciledBalanceInCurrency(account, report_commodity, include_children):
    r"""xaccAccountGetReconciledBalanceInCurrency(Account const * account, gnc_commodity const * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetReconciledBalanceInCurrency(account, report_commodity, include_children)

def xaccAccountGetPresentBalanceInCurrency(account, report_commodity, include_children):
    r"""xaccAccountGetPresentBalanceInCurrency(Account const * account, gnc_commodity const * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetPresentBalanceInCurrency(account, report_commodity, include_children)

def xaccAccountGetProjectedMinimumBalanceInCurrency(account, report_commodity, include_children):
    r"""xaccAccountGetProjectedMinimumBalanceInCurrency(Account const * account, gnc_commodity const * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetProjectedMinimumBalanceInCurrency(account, report_commodity, include_children)

def xaccAccountGetNoclosingBalanceAsOfDateInCurrency(acc, date, report_commodity, include_children):
    r"""xaccAccountGetNoclosingBalanceAsOfDateInCurrency(Account * acc, time64 date, gnc_commodity * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetNoclosingBalanceAsOfDateInCurrency(acc, date, report_commodity, include_children)

def xaccAccountGetBalanceAsOfDateInCurrency(account, date, report_commodity, include_children):
    r"""xaccAccountGetBalanceAsOfDateInCurrency(Account * account, time64 date, gnc_commodity * report_commodity, gboolean include_children) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetBalanceAsOfDateInCurrency(account, date, report_commodity, include_children)

def xaccAccountGetNoclosingBalanceChangeForPeriod(acc, date1, date2, recurse):
    r"""xaccAccountGetNoclosingBalanceChangeForPeriod(Account * acc, time64 date1, time64 date2, gboolean recurse) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetNoclosingBalanceChangeForPeriod(acc, date1, date2, recurse)

def xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod(acc, date1, date2, recurse):
    r"""xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod(Account * acc, time64 date1, time64 date2, gboolean recurse) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetNoclosingBalanceChangeInCurrencyForPeriod(acc, date1, date2, recurse)

def xaccAccountGetBalanceChangeForPeriod(acc, date1, date2, recurse):
    r"""xaccAccountGetBalanceChangeForPeriod(Account * acc, time64 date1, time64 date2, gboolean recurse) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetBalanceChangeForPeriod(acc, date1, date2, recurse)

def gnc_account_append_child(new_parent, child):
    r"""gnc_account_append_child(Account * new_parent, Account * child)"""
    return _gnucash_core_c.gnc_account_append_child(new_parent, child)

def gnc_account_remove_child(parent, child):
    r"""gnc_account_remove_child(Account * parent, Account * child)"""
    return _gnucash_core_c.gnc_account_remove_child(parent, child)

def gnc_account_get_parent(account):
    r"""gnc_account_get_parent(Account const * account) -> Account *"""
    return _gnucash_core_c.gnc_account_get_parent(account)

def gnc_account_get_root(account):
    r"""gnc_account_get_root(Account * account) -> Account *"""
    return _gnucash_core_c.gnc_account_get_root(account)

def gnc_account_is_root(account):
    r"""gnc_account_is_root(Account const * account) -> gboolean"""
    return _gnucash_core_c.gnc_account_is_root(account)

def gnc_account_n_children(account):
    r"""gnc_account_n_children(Account const * account) -> gint"""
    return _gnucash_core_c.gnc_account_n_children(account)

def gnc_account_child_index(parent, child):
    r"""gnc_account_child_index(Account const * parent, Account const * child) -> gint"""
    return _gnucash_core_c.gnc_account_child_index(parent, child)

def gnc_account_nth_child(parent, num):
    r"""gnc_account_nth_child(Account const * parent, gint num) -> Account *"""
    return _gnucash_core_c.gnc_account_nth_child(parent, num)

def gnc_account_n_descendants(account):
    r"""gnc_account_n_descendants(Account const * account) -> gint"""
    return _gnucash_core_c.gnc_account_n_descendants(account)

def gnc_account_get_current_depth(account):
    r"""gnc_account_get_current_depth(Account const * account) -> gint"""
    return _gnucash_core_c.gnc_account_get_current_depth(account)

def gnc_account_get_tree_depth(account):
    r"""gnc_account_get_tree_depth(Account const * account) -> gint"""
    return _gnucash_core_c.gnc_account_get_tree_depth(account)

def gnc_account_foreach_child(account, func, user_data):
    r"""gnc_account_foreach_child(Account const * account, AccountCb func, gpointer user_data)"""
    return _gnucash_core_c.gnc_account_foreach_child(account, func, user_data)

def gnc_account_foreach_descendant(account, func, user_data):
    r"""gnc_account_foreach_descendant(Account const * account, AccountCb func, gpointer user_data)"""
    return _gnucash_core_c.gnc_account_foreach_descendant(account, func, user_data)

def gnc_account_foreach_descendant_until(account, func, user_data):
    r"""gnc_account_foreach_descendant_until(Account const * account, AccountCb2 func, gpointer user_data) -> gpointer"""
    return _gnucash_core_c.gnc_account_foreach_descendant_until(account, func, user_data)

def gnc_account_join_children(to_parent, from_parent):
    r"""gnc_account_join_children(Account * to_parent, Account * from_parent)"""
    return _gnucash_core_c.gnc_account_join_children(to_parent, from_parent)

def gnc_account_merge_children(parent):
    r"""gnc_account_merge_children(Account * parent)"""
    return _gnucash_core_c.gnc_account_merge_children(parent)

def xaccAccountSetReconcileChildrenStatus(account, status):
    r"""xaccAccountSetReconcileChildrenStatus(Account * account, gboolean status)"""
    return _gnucash_core_c.xaccAccountSetReconcileChildrenStatus(account, status)

def xaccAccountGetReconcileChildrenStatus(account):
    r"""xaccAccountGetReconcileChildrenStatus(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetReconcileChildrenStatus(account)

def xaccAccountHasAncestor(acc, ancestor):
    r"""xaccAccountHasAncestor(Account const * acc, Account const * ancestor) -> gboolean"""
    return _gnucash_core_c.xaccAccountHasAncestor(acc, ancestor)

def gnc_account_lookup_by_name(parent, name):
    r"""gnc_account_lookup_by_name(Account const * parent, char const * name) -> Account *"""
    return _gnucash_core_c.gnc_account_lookup_by_name(parent, name)

def gnc_account_lookup_by_full_name(any_account, name):
    r"""gnc_account_lookup_by_full_name(Account const * any_account, gchar const * name) -> Account *"""
    return _gnucash_core_c.gnc_account_lookup_by_full_name(any_account, name)

def gnc_account_lookup_by_code(parent, code):
    r"""gnc_account_lookup_by_code(Account const * parent, char const * code) -> Account *"""
    return _gnucash_core_c.gnc_account_lookup_by_code(parent, code)

def gnc_account_lookup_by_opening_balance(account, commodity):
    r"""gnc_account_lookup_by_opening_balance(Account * account, gnc_commodity * commodity) -> Account *"""
    return _gnucash_core_c.gnc_account_lookup_by_opening_balance(account, commodity)

def gnc_account_lookup_by_type_and_commodity(root, name, acctype, commodity):
    r"""gnc_account_lookup_by_type_and_commodity(Account * root, char const * name, GNCAccountType acctype, gnc_commodity * commodity) -> GList *"""
    return _gnucash_core_c.gnc_account_lookup_by_type_and_commodity(root, name, acctype, commodity)

def xaccAccountTypeEnumAsString(type):
    r"""xaccAccountTypeEnumAsString(GNCAccountType type) -> char const *"""
    return _gnucash_core_c.xaccAccountTypeEnumAsString(type)

def xaccAccountStringToType(str, type):
    r"""xaccAccountStringToType(char const * str, GNCAccountType * type) -> gboolean"""
    return _gnucash_core_c.xaccAccountStringToType(str, type)

def xaccAccountStringToEnum(str):
    r"""xaccAccountStringToEnum(char const * str) -> GNCAccountType"""
    return _gnucash_core_c.xaccAccountStringToEnum(str)

def xaccAccountGetTypeStr(type):
    r"""xaccAccountGetTypeStr(GNCAccountType type) -> char const *"""
    return _gnucash_core_c.xaccAccountGetTypeStr(type)

def xaccAccountTypesCompatibleWith(type):
    r"""xaccAccountTypesCompatibleWith(GNCAccountType type) -> guint32"""
    return _gnucash_core_c.xaccAccountTypesCompatibleWith(type)

def xaccParentAccountTypesCompatibleWith(type):
    r"""xaccParentAccountTypesCompatibleWith(GNCAccountType type) -> guint32"""
    return _gnucash_core_c.xaccParentAccountTypesCompatibleWith(type)

def xaccAccountTypesCompatible(parent_type, child_type):
    r"""xaccAccountTypesCompatible(GNCAccountType parent_type, GNCAccountType child_type) -> gboolean"""
    return _gnucash_core_c.xaccAccountTypesCompatible(parent_type, child_type)

def xaccAccountTypesValid():
    r"""xaccAccountTypesValid() -> guint32"""
    return _gnucash_core_c.xaccAccountTypesValid()

def xaccAccountIsAssetLiabType(t):
    r"""xaccAccountIsAssetLiabType(GNCAccountType t) -> gboolean"""
    return _gnucash_core_c.xaccAccountIsAssetLiabType(t)

def xaccAccountTypeGetFundamental(t):
    r"""xaccAccountTypeGetFundamental(GNCAccountType t) -> GNCAccountType"""
    return _gnucash_core_c.xaccAccountTypeGetFundamental(t)

def xaccAccountIsAPARType(t):
    r"""xaccAccountIsAPARType(GNCAccountType t) -> gboolean"""
    return _gnucash_core_c.xaccAccountIsAPARType(t)

def xaccAccountIsEquityType(t):
    r"""xaccAccountIsEquityType(GNCAccountType t) -> gboolean"""
    return _gnucash_core_c.xaccAccountIsEquityType(t)

def xaccAccountGetSplitList(account):
    r"""xaccAccountGetSplitList(Account const * account) -> SplitList *"""
    return _gnucash_core_c.xaccAccountGetSplitList(account)

def xaccAccountGetSplitsSize(account):
    r"""xaccAccountGetSplitsSize(Account const * account) -> size_t"""
    return _gnucash_core_c.xaccAccountGetSplitsSize(account)

def xaccAccountMoveAllSplits(accfrom, accto):
    r"""xaccAccountMoveAllSplits(Account * accfrom, Account * accto)"""
    return _gnucash_core_c.xaccAccountMoveAllSplits(accfrom, accto)

def xaccAccountForEachTransaction(account, proc, data):
    r"""xaccAccountForEachTransaction(Account const * account, TransactionCallback proc, void * data) -> gint"""
    return _gnucash_core_c.xaccAccountForEachTransaction(account, proc, data)

def xaccAccountFindTransByDesc(account, description):
    r"""xaccAccountFindTransByDesc(Account const * account, char const * description) -> Transaction *"""
    return _gnucash_core_c.xaccAccountFindTransByDesc(account, description)

def xaccAccountFindSplitByDesc(account, description):
    r"""xaccAccountFindSplitByDesc(Account const * account, char const * description) -> Split *"""
    return _gnucash_core_c.xaccAccountFindSplitByDesc(account, description)

def xaccAccountInsertLot(arg1, arg2):
    r"""xaccAccountInsertLot(Account * arg1, GNCLot * arg2)"""
    return _gnucash_core_c.xaccAccountInsertLot(arg1, arg2)

def xaccAccountRemoveLot(arg1, arg2):
    r"""xaccAccountRemoveLot(Account * arg1, GNCLot * arg2)"""
    return _gnucash_core_c.xaccAccountRemoveLot(arg1, arg2)

def xaccAccountGetLotList(account):
    r"""xaccAccountGetLotList(Account const * account) -> LotList *"""
    return _gnucash_core_c.xaccAccountGetLotList(account)

def xaccAccountForEachLot(acc, proc, user_data):
    r"""xaccAccountForEachLot(Account const * acc, gpointer (*)(GNCLot *,gpointer) proc, gpointer user_data) -> gpointer"""
    return _gnucash_core_c.xaccAccountForEachLot(acc, proc, user_data)

def xaccAccountFindOpenLots(acc, match_func, user_data, sort_func):
    r"""xaccAccountFindOpenLots(Account const * acc, gboolean (*)(GNCLot *,gpointer) match_func, gpointer user_data, GCompareFunc sort_func) -> LotList *"""
    return _gnucash_core_c.xaccAccountFindOpenLots(acc, match_func, user_data, sort_func)

def xaccAccountGetReconcileLastDate(account):
    r"""xaccAccountGetReconcileLastDate(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetReconcileLastDate(account)

def xaccAccountSetReconcileLastDate(account, last_date):
    r"""xaccAccountSetReconcileLastDate(Account * account, time64 last_date)"""
    return _gnucash_core_c.xaccAccountSetReconcileLastDate(account, last_date)

def xaccAccountGetReconcileLastInterval(account, months, days):
    r"""xaccAccountGetReconcileLastInterval(Account const * account, int * months, int * days) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetReconcileLastInterval(account, months, days)

def xaccAccountSetReconcileLastInterval(account, months, days):
    r"""xaccAccountSetReconcileLastInterval(Account * account, int months, int days)"""
    return _gnucash_core_c.xaccAccountSetReconcileLastInterval(account, months, days)

def xaccAccountGetReconcilePostponeDate(account):
    r"""xaccAccountGetReconcilePostponeDate(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetReconcilePostponeDate(account)

def xaccAccountSetReconcilePostponeDate(account, postpone_date):
    r"""xaccAccountSetReconcilePostponeDate(Account * account, time64 postpone_date)"""
    return _gnucash_core_c.xaccAccountSetReconcilePostponeDate(account, postpone_date)

def xaccAccountGetReconcilePostponeBalance(account, balance):
    r"""xaccAccountGetReconcilePostponeBalance(Account const * account, _gnc_numeric balance) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetReconcilePostponeBalance(account, balance)

def xaccAccountSetReconcilePostponeBalance(account, balance):
    r"""xaccAccountSetReconcilePostponeBalance(Account * account, _gnc_numeric balance)"""
    return _gnucash_core_c.xaccAccountSetReconcilePostponeBalance(account, balance)

def xaccAccountClearReconcilePostpone(account):
    r"""xaccAccountClearReconcilePostpone(Account * account)"""
    return _gnucash_core_c.xaccAccountClearReconcilePostpone(account)

def xaccAccountGetHigherBalanceLimit(account, balance):
    r"""xaccAccountGetHigherBalanceLimit(Account const * account, _gnc_numeric balance) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetHigherBalanceLimit(account, balance)

def xaccAccountSetHigherBalanceLimit(account, balance):
    r"""xaccAccountSetHigherBalanceLimit(Account * account, _gnc_numeric balance)"""
    return _gnucash_core_c.xaccAccountSetHigherBalanceLimit(account, balance)

def xaccAccountClearHigherBalanceLimit(account):
    r"""xaccAccountClearHigherBalanceLimit(Account * account)"""
    return _gnucash_core_c.xaccAccountClearHigherBalanceLimit(account)

def xaccAccountGetLowerBalanceLimit(account, balance):
    r"""xaccAccountGetLowerBalanceLimit(Account const * account, _gnc_numeric balance) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetLowerBalanceLimit(account, balance)

def xaccAccountSetLowerBalanceLimit(account, balance):
    r"""xaccAccountSetLowerBalanceLimit(Account * account, _gnc_numeric balance)"""
    return _gnucash_core_c.xaccAccountSetLowerBalanceLimit(account, balance)

def xaccAccountClearLowerBalanceLimit(account):
    r"""xaccAccountClearLowerBalanceLimit(Account * account)"""
    return _gnucash_core_c.xaccAccountClearLowerBalanceLimit(account)

def xaccAccountGetIncludeSubAccountBalances(account):
    r"""xaccAccountGetIncludeSubAccountBalances(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetIncludeSubAccountBalances(account)

def xaccAccountSetIncludeSubAccountBalances(account, include):
    r"""xaccAccountSetIncludeSubAccountBalances(Account * account, gboolean include)"""
    return _gnucash_core_c.xaccAccountSetIncludeSubAccountBalances(account, include)
PLACEHOLDER_NONE = _gnucash_core_c.PLACEHOLDER_NONE

PLACEHOLDER_THIS = _gnucash_core_c.PLACEHOLDER_THIS

PLACEHOLDER_CHILD = _gnucash_core_c.PLACEHOLDER_CHILD


def xaccAccountGetPlaceholder(account):
    r"""xaccAccountGetPlaceholder(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetPlaceholder(account)

def xaccAccountSetPlaceholder(account, val):
    r"""xaccAccountSetPlaceholder(Account * account, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetPlaceholder(account, val)

def xaccAccountGetAppendText(account):
    r"""xaccAccountGetAppendText(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetAppendText(account)

def xaccAccountSetAppendText(account, val):
    r"""xaccAccountSetAppendText(Account * account, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetAppendText(account, val)

def xaccAccountGetIsOpeningBalance(account):
    r"""xaccAccountGetIsOpeningBalance(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetIsOpeningBalance(account)

def xaccAccountSetIsOpeningBalance(account, val):
    r"""xaccAccountSetIsOpeningBalance(Account * account, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetIsOpeningBalance(account, val)

def xaccAccountGetDescendantPlaceholder(account):
    r"""xaccAccountGetDescendantPlaceholder(Account const * account) -> GNCPlaceholderType"""
    return _gnucash_core_c.xaccAccountGetDescendantPlaceholder(account)

def xaccAccountGetHidden(acc):
    r"""xaccAccountGetHidden(Account const * acc) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetHidden(acc)

def xaccAccountSetHidden(acc, val):
    r"""xaccAccountSetHidden(Account * acc, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetHidden(acc, val)

def xaccAccountIsHidden(acc):
    r"""xaccAccountIsHidden(Account const * acc) -> gboolean"""
    return _gnucash_core_c.xaccAccountIsHidden(acc)

def xaccAccountGetAutoInterest(acc):
    r"""xaccAccountGetAutoInterest(Account const * acc) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetAutoInterest(acc)

def xaccAccountSetAutoInterest(acc, val):
    r"""xaccAccountSetAutoInterest(Account * acc, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetAutoInterest(acc, val)

def xaccAccountGetTaxRelated(account):
    r"""xaccAccountGetTaxRelated(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetTaxRelated(account)

def xaccAccountSetTaxRelated(account, tax_related):
    r"""xaccAccountSetTaxRelated(Account * account, gboolean tax_related)"""
    return _gnucash_core_c.xaccAccountSetTaxRelated(account, tax_related)

def xaccAccountGetTaxUSCode(account):
    r"""xaccAccountGetTaxUSCode(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetTaxUSCode(account)

def xaccAccountSetTaxUSCode(account, code):
    r"""xaccAccountSetTaxUSCode(Account * account, char const * code)"""
    return _gnucash_core_c.xaccAccountSetTaxUSCode(account, code)

def xaccAccountGetTaxUSPayerNameSource(account):
    r"""xaccAccountGetTaxUSPayerNameSource(Account const * account) -> char const *"""
    return _gnucash_core_c.xaccAccountGetTaxUSPayerNameSource(account)

def xaccAccountSetTaxUSPayerNameSource(account, source):
    r"""xaccAccountSetTaxUSPayerNameSource(Account * account, char const * source)"""
    return _gnucash_core_c.xaccAccountSetTaxUSPayerNameSource(account, source)

def xaccAccountGetTaxUSCopyNumber(account):
    r"""xaccAccountGetTaxUSCopyNumber(Account const * account) -> gint64"""
    return _gnucash_core_c.xaccAccountGetTaxUSCopyNumber(account)

def xaccAccountSetTaxUSCopyNumber(account, copy_number):
    r"""xaccAccountSetTaxUSCopyNumber(Account * account, gint64 copy_number)"""
    return _gnucash_core_c.xaccAccountSetTaxUSCopyNumber(account, copy_number)

def gnc_account_get_debit_string(acct_type):
    r"""gnc_account_get_debit_string(GNCAccountType acct_type) -> char const *"""
    return _gnucash_core_c.gnc_account_get_debit_string(acct_type)

def gnc_account_get_credit_string(acct_type):
    r"""gnc_account_get_credit_string(GNCAccountType acct_type) -> char const *"""
    return _gnucash_core_c.gnc_account_get_credit_string(acct_type)

def xaccAccountSetMark(account, mark):
    r"""xaccAccountSetMark(Account * account, short mark)"""
    return _gnucash_core_c.xaccAccountSetMark(account, mark)

def xaccClearMark(account, val):
    r"""xaccClearMark(Account * account, short val)"""
    return _gnucash_core_c.xaccClearMark(account, val)

def xaccClearMarkDown(account, val):
    r"""xaccClearMarkDown(Account * account, short val)"""
    return _gnucash_core_c.xaccClearMarkDown(account, val)

def gnc_account_tree_begin_staged_transaction_traversals(acc):
    r"""gnc_account_tree_begin_staged_transaction_traversals(Account * acc)"""
    return _gnucash_core_c.gnc_account_tree_begin_staged_transaction_traversals(acc)

def xaccAccountBeginStagedTransactionTraversals(account):
    r"""xaccAccountBeginStagedTransactionTraversals(Account const * account)"""
    return _gnucash_core_c.xaccAccountBeginStagedTransactionTraversals(account)

def xaccTransactionTraverse(trans, stage):
    r"""xaccTransactionTraverse(Transaction * trans, int stage) -> gboolean"""
    return _gnucash_core_c.xaccTransactionTraverse(trans, stage)

def xaccAccountStagedTransactionTraversal(a, stage, thunk, data):
    r"""xaccAccountStagedTransactionTraversal(Account const * a, unsigned int stage, TransactionCallback thunk, void * data) -> int"""
    return _gnucash_core_c.xaccAccountStagedTransactionTraversal(a, stage, thunk, data)

def gnc_account_tree_staged_transaction_traversal(account, stage, thunk, data):
    r"""gnc_account_tree_staged_transaction_traversal(Account const * account, unsigned int stage, TransactionCallback thunk, void * data) -> int"""
    return _gnucash_core_c.gnc_account_tree_staged_transaction_traversal(account, stage, thunk, data)

def xaccAccountTreeForEachTransaction(acc, proc, data):
    r"""xaccAccountTreeForEachTransaction(Account * acc, TransactionCallback proc, void * data) -> int"""
    return _gnucash_core_c.xaccAccountTreeForEachTransaction(acc, proc, data)

def gnc_account_get_earliest_date(account):
    r"""gnc_account_get_earliest_date(Account const * account) -> time64"""
    return _gnucash_core_c.gnc_account_get_earliest_date(account)

def gnc_account_imap_find_account(acc, category, key):
    r"""gnc_account_imap_find_account(Account * acc, char const * category, char const * key) -> Account *"""
    return _gnucash_core_c.gnc_account_imap_find_account(acc, category, key)

def gnc_account_imap_find_any(book, category, key):
    r"""gnc_account_imap_find_any(QofBook * book, char const * category, char const * key) -> Account *"""
    return _gnucash_core_c.gnc_account_imap_find_any(book, category, key)

def gnc_account_imap_add_account(acc, category, key, added_acc):
    r"""gnc_account_imap_add_account(Account * acc, char const * category, char const * key, Account * added_acc)"""
    return _gnucash_core_c.gnc_account_imap_add_account(acc, category, key, added_acc)

def gnc_account_imap_delete_account(acc, category, key):
    r"""gnc_account_imap_delete_account(Account * acc, char const * category, char const * key)"""
    return _gnucash_core_c.gnc_account_imap_delete_account(acc, category, key)

def gnc_account_imap_find_account_bayes(acc, tokens):
    r"""gnc_account_imap_find_account_bayes(Account * acc, GList * tokens) -> Account *"""
    return _gnucash_core_c.gnc_account_imap_find_account_bayes(acc, tokens)

def gnc_account_imap_add_account_bayes(acc, tokens, added_acc):
    r"""gnc_account_imap_add_account_bayes(Account * acc, GList * tokens, Account * added_acc)"""
    return _gnucash_core_c.gnc_account_imap_add_account_bayes(acc, tokens, added_acc)
class GncImapInfo(object):
    r"""Proxy of C imap_info struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    source_account = property(_gnucash_core_c.GncImapInfo_source_account_get, _gnucash_core_c.GncImapInfo_source_account_set, doc=r"""source_account : p.Account""")
    map_account = property(_gnucash_core_c.GncImapInfo_map_account_get, _gnucash_core_c.GncImapInfo_map_account_set, doc=r"""map_account : p.Account""")
    list = property(_gnucash_core_c.GncImapInfo_list_get, _gnucash_core_c.GncImapInfo_list_set, doc=r"""list : p.GList""")
    head = property(_gnucash_core_c.GncImapInfo_head_get, _gnucash_core_c.GncImapInfo_head_set, doc=r"""head : p.char""")
    category = property(_gnucash_core_c.GncImapInfo_category_get, _gnucash_core_c.GncImapInfo_category_set, doc=r"""category : p.char""")
    match_string = property(_gnucash_core_c.GncImapInfo_match_string_get, _gnucash_core_c.GncImapInfo_match_string_set, doc=r"""match_string : p.char""")
    count = property(_gnucash_core_c.GncImapInfo_count_get, _gnucash_core_c.GncImapInfo_count_set, doc=r"""count : p.char""")

    def __init__(self):
        r"""__init__(GncImapInfo self) -> GncImapInfo"""
        _gnucash_core_c.GncImapInfo_swiginit(self, _gnucash_core_c.new_GncImapInfo())
    __swig_destroy__ = _gnucash_core_c.delete_GncImapInfo

# Register GncImapInfo in _gnucash_core_c:
_gnucash_core_c.GncImapInfo_swigregister(GncImapInfo)

def gnc_account_imap_info_destroy(arg1):
    r"""gnc_account_imap_info_destroy(GncImapInfo arg1)"""
    return _gnucash_core_c.gnc_account_imap_info_destroy(arg1)

def gnc_account_imap_get_info_bayes(acc):
    r"""gnc_account_imap_get_info_bayes(Account * acc) -> GList *"""
    return _gnucash_core_c.gnc_account_imap_get_info_bayes(acc)

def gnc_account_imap_get_info(acc, category):
    r"""gnc_account_imap_get_info(Account * acc, char const * category) -> GList *"""
    return _gnucash_core_c.gnc_account_imap_get_info(acc, category)

def gnc_account_get_map_entry(acc, head, category):
    r"""gnc_account_get_map_entry(Account * acc, char const * head, char const * category) -> gchar *"""
    return _gnucash_core_c.gnc_account_get_map_entry(acc, head, category)

def gnc_account_get_map_guid_entry(acc, head, category):
    r"""gnc_account_get_map_guid_entry(Account * acc, char const * head, char const * category) -> GncGUID"""
    return _gnucash_core_c.gnc_account_get_map_guid_entry(acc, head, category)

def gnc_account_delete_map_entry(acc, head, category, match_string, empty):
    r"""gnc_account_delete_map_entry(Account * acc, char * head, char * category, char * match_string, gboolean empty)"""
    return _gnucash_core_c.gnc_account_delete_map_entry(acc, head, category, match_string, empty)

def gnc_account_delete_all_bayes_maps(acc):
    r"""gnc_account_delete_all_bayes_maps(Account * acc)"""
    return _gnucash_core_c.gnc_account_delete_all_bayes_maps(acc)

def gnc_account_reset_convert_bayes_to_flat():
    r"""gnc_account_reset_convert_bayes_to_flat()"""
    return _gnucash_core_c.gnc_account_reset_convert_bayes_to_flat()

def DxaccAccountSetCurrency(account, currency):
    r"""DxaccAccountSetCurrency(Account * account, gnc_commodity * currency)"""
    return _gnucash_core_c.DxaccAccountSetCurrency(account, currency)

def DxaccAccountGetCurrency(account):
    r"""DxaccAccountGetCurrency(Account const * account) -> gnc_commodity *"""
    return _gnucash_core_c.DxaccAccountGetCurrency(account)

def dxaccAccountSetQuoteTZ(account, tz):
    r"""dxaccAccountSetQuoteTZ(Account * account, char const * tz)"""
    return _gnucash_core_c.dxaccAccountSetQuoteTZ(account, tz)

def dxaccAccountGetQuoteTZ(account):
    r"""dxaccAccountGetQuoteTZ(Account const * account) -> char const *"""
    return _gnucash_core_c.dxaccAccountGetQuoteTZ(account)
ACCOUNT_KVP = _gnucash_core_c.ACCOUNT_KVP

ACCOUNT_NAME_ = _gnucash_core_c.ACCOUNT_NAME_

ACCOUNT_CODE_ = _gnucash_core_c.ACCOUNT_CODE_

ACCOUNT_DESCRIPTION_ = _gnucash_core_c.ACCOUNT_DESCRIPTION_

ACCOUNT_COLOR_ = _gnucash_core_c.ACCOUNT_COLOR_

ACCOUNT_FILTER_ = _gnucash_core_c.ACCOUNT_FILTER_

ACCOUNT_SORT_ORDER_ = _gnucash_core_c.ACCOUNT_SORT_ORDER_

ACCOUNT_SORT_REVERSED_ = _gnucash_core_c.ACCOUNT_SORT_REVERSED_

ACCOUNT_NOTES_ = _gnucash_core_c.ACCOUNT_NOTES_

ACCOUNT_BALANCE_ = _gnucash_core_c.ACCOUNT_BALANCE_

ACCOUNT_NOCLOSING_ = _gnucash_core_c.ACCOUNT_NOCLOSING_

ACCOUNT_OPENING_BALANCE_ = _gnucash_core_c.ACCOUNT_OPENING_BALANCE_

ACCOUNT_CLEARED_ = _gnucash_core_c.ACCOUNT_CLEARED_

ACCOUNT_RECONCILED_ = _gnucash_core_c.ACCOUNT_RECONCILED_

ACCOUNT_PRESENT_ = _gnucash_core_c.ACCOUNT_PRESENT_

ACCOUNT_FUTURE_MINIMUM_ = _gnucash_core_c.ACCOUNT_FUTURE_MINIMUM_

ACCOUNT_TAX_RELATED = _gnucash_core_c.ACCOUNT_TAX_RELATED

ACCOUNT_TYPE_ = _gnucash_core_c.ACCOUNT_TYPE_

ACCOUNT_SCU = _gnucash_core_c.ACCOUNT_SCU

ACCOUNT_NSCU = _gnucash_core_c.ACCOUNT_NSCU

ACCOUNT_PARENT = _gnucash_core_c.ACCOUNT_PARENT

ACCOUNT_MATCH_ALL_TYPE = _gnucash_core_c.ACCOUNT_MATCH_ALL_TYPE


def gnc_transaction_get_type():
    r"""gnc_transaction_get_type() -> GType"""
    return _gnucash_core_c.gnc_transaction_get_type()
TXN_TYPE_UNCACHED = _gnucash_core_c.TXN_TYPE_UNCACHED

TXN_TYPE_NONE = _gnucash_core_c.TXN_TYPE_NONE

TXN_TYPE_INVOICE = _gnucash_core_c.TXN_TYPE_INVOICE

TXN_TYPE_PAYMENT = _gnucash_core_c.TXN_TYPE_PAYMENT

TXN_TYPE_LINK = _gnucash_core_c.TXN_TYPE_LINK


def xaccMallocTransaction(book):
    r"""xaccMallocTransaction(QofBook * book) -> Transaction *"""
    return _gnucash_core_c.xaccMallocTransaction(book)

def xaccTransDestroy(trans):
    r"""xaccTransDestroy(Transaction * trans)"""
    return _gnucash_core_c.xaccTransDestroy(trans)

def xaccTransClone(t):
    r"""xaccTransClone(Transaction const * t) -> Transaction *"""
    return _gnucash_core_c.xaccTransClone(t)

def xaccTransCloneNoKvp(t):
    r"""xaccTransCloneNoKvp(Transaction const * t) -> Transaction *"""
    return _gnucash_core_c.xaccTransCloneNoKvp(t)

def xaccTransEqual(ta, tb, check_guids, check_splits, check_balances, assume_ordered):
    r"""xaccTransEqual(Transaction const * ta, Transaction const * tb, gboolean check_guids, gboolean check_splits, gboolean check_balances, gboolean assume_ordered) -> gboolean"""
    return _gnucash_core_c.xaccTransEqual(ta, tb, check_guids, check_splits, check_balances, assume_ordered)

def xaccTransBeginEdit(trans):
    r"""xaccTransBeginEdit(Transaction * trans)"""
    return _gnucash_core_c.xaccTransBeginEdit(trans)

def xaccTransCommitEdit(trans):
    r"""xaccTransCommitEdit(Transaction * trans)"""
    return _gnucash_core_c.xaccTransCommitEdit(trans)

def xaccTransRollbackEdit(trans):
    r"""xaccTransRollbackEdit(Transaction * trans)"""
    return _gnucash_core_c.xaccTransRollbackEdit(trans)

def xaccTransIsOpen(trans):
    r"""xaccTransIsOpen(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransIsOpen(trans)

def xaccTransLookup(guid, book):
    r"""xaccTransLookup(GncGUID guid, QofBook * book) -> Transaction *"""
    return _gnucash_core_c.xaccTransLookup(guid, book)

def xaccTransCopyToClipBoard(from_trans):
    r"""xaccTransCopyToClipBoard(Transaction const * from_trans) -> Transaction *"""
    return _gnucash_core_c.xaccTransCopyToClipBoard(from_trans)

def xaccTransCopyOnto(from_trans, to_trans):
    r"""xaccTransCopyOnto(Transaction const * from_trans, Transaction * to_trans)"""
    return _gnucash_core_c.xaccTransCopyOnto(from_trans, to_trans)

def xaccTransCopyFromClipBoard(from_trans, to_trans, from_acc, to_acc, no_date):
    r"""xaccTransCopyFromClipBoard(Transaction const * from_trans, Transaction * to_trans, Account const * from_acc, Account * to_acc, gboolean no_date)"""
    return _gnucash_core_c.xaccTransCopyFromClipBoard(from_trans, to_trans, from_acc, to_acc, no_date)

def xaccTransFindSplitByAccount(trans, acc):
    r"""xaccTransFindSplitByAccount(Transaction const * trans, Account const * acc) -> Split *"""
    return _gnucash_core_c.xaccTransFindSplitByAccount(trans, acc)

def xaccTransScrubGains(trans, gain_acc):
    r"""xaccTransScrubGains(Transaction * trans, Account * gain_acc)"""
    return _gnucash_core_c.xaccTransScrubGains(trans, gain_acc)

def gnc_book_count_transactions(book):
    r"""gnc_book_count_transactions(QofBook * book) -> guint"""
    return _gnucash_core_c.gnc_book_count_transactions(book)

def xaccTransUseTradingAccounts(trans):
    r"""xaccTransUseTradingAccounts(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransUseTradingAccounts(trans)

def xaccTransSortSplits(trans):
    r"""xaccTransSortSplits(Transaction * trans)"""
    return _gnucash_core_c.xaccTransSortSplits(trans)

def xaccTransSetTxnType(trans, type):
    r"""xaccTransSetTxnType(Transaction * trans, char type)"""
    return _gnucash_core_c.xaccTransSetTxnType(trans, type)

def xaccTransGetTxnType(trans):
    r"""xaccTransGetTxnType(Transaction * trans) -> char"""
    return _gnucash_core_c.xaccTransGetTxnType(trans)

def xaccTransSetNum(trans, num):
    r"""xaccTransSetNum(Transaction * trans, char const * num)"""
    return _gnucash_core_c.xaccTransSetNum(trans, num)

def xaccTransSetDescription(trans, desc):
    r"""xaccTransSetDescription(Transaction * trans, char const * desc)"""
    return _gnucash_core_c.xaccTransSetDescription(trans, desc)

def xaccTransSetDocLink(trans, doclink):
    r"""xaccTransSetDocLink(Transaction * trans, char const * doclink)"""
    return _gnucash_core_c.xaccTransSetDocLink(trans, doclink)

def xaccTransSetNotes(trans, notes):
    r"""xaccTransSetNotes(Transaction * trans, char const * notes)"""
    return _gnucash_core_c.xaccTransSetNotes(trans, notes)

def xaccTransGetNum(trans):
    r"""xaccTransGetNum(Transaction const * trans) -> char const *"""
    return _gnucash_core_c.xaccTransGetNum(trans)

def xaccTransGetDescription(trans):
    r"""xaccTransGetDescription(Transaction const * trans) -> char const *"""
    return _gnucash_core_c.xaccTransGetDescription(trans)

def xaccTransGetDocLink(trans):
    r"""xaccTransGetDocLink(Transaction const * trans) -> char const *"""
    return _gnucash_core_c.xaccTransGetDocLink(trans)

def xaccTransGetNotes(trans):
    r"""xaccTransGetNotes(Transaction const * trans) -> char const *"""
    return _gnucash_core_c.xaccTransGetNotes(trans)

def xaccTransSetIsClosingTxn(trans, is_closing):
    r"""xaccTransSetIsClosingTxn(Transaction * trans, gboolean is_closing)"""
    return _gnucash_core_c.xaccTransSetIsClosingTxn(trans, is_closing)

def xaccTransGetIsClosingTxn(trans):
    r"""xaccTransGetIsClosingTxn(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransGetIsClosingTxn(trans)

def xaccTransClearSplits(trans):
    r"""xaccTransClearSplits(Transaction * trans)"""
    return _gnucash_core_c.xaccTransClearSplits(trans)

def xaccTransGetSplit(trans, i):
    r"""xaccTransGetSplit(Transaction const * trans, int i) -> Split *"""
    return _gnucash_core_c.xaccTransGetSplit(trans, i)

def xaccTransGetSplitIndex(trans, split):
    r"""xaccTransGetSplitIndex(Transaction const * trans, Split const * split) -> int"""
    return _gnucash_core_c.xaccTransGetSplitIndex(trans, split)

def xaccTransGetSplitList(trans):
    r"""xaccTransGetSplitList(Transaction const * trans) -> SplitList *"""
    return _gnucash_core_c.xaccTransGetSplitList(trans)

def xaccTransGetPaymentAcctSplitList(trans):
    r"""xaccTransGetPaymentAcctSplitList(Transaction const * trans) -> SplitList *"""
    return _gnucash_core_c.xaccTransGetPaymentAcctSplitList(trans)

def xaccTransGetAPARAcctSplitList(trans, strict):
    r"""xaccTransGetAPARAcctSplitList(Transaction const * trans, gboolean strict) -> SplitList *"""
    return _gnucash_core_c.xaccTransGetAPARAcctSplitList(trans, strict)

def xaccTransStillHasSplit(trans, s):
    r"""xaccTransStillHasSplit(Transaction const * trans, Split const * s) -> gboolean"""
    return _gnucash_core_c.xaccTransStillHasSplit(trans, s)

def xaccTransGetFirstPaymentAcctSplit(trans):
    r"""xaccTransGetFirstPaymentAcctSplit(Transaction const * trans) -> Split *"""
    return _gnucash_core_c.xaccTransGetFirstPaymentAcctSplit(trans)

def xaccTransGetFirstAPARAcctSplit(trans, strict):
    r"""xaccTransGetFirstAPARAcctSplit(Transaction const * trans, gboolean strict) -> Split *"""
    return _gnucash_core_c.xaccTransGetFirstAPARAcctSplit(trans, strict)

def xaccTransSetReadOnly(trans, reason):
    r"""xaccTransSetReadOnly(Transaction * trans, char const * reason)"""
    return _gnucash_core_c.xaccTransSetReadOnly(trans, reason)

def xaccTransClearReadOnly(trans):
    r"""xaccTransClearReadOnly(Transaction * trans)"""
    return _gnucash_core_c.xaccTransClearReadOnly(trans)

def xaccTransGetReadOnly(trans):
    r"""xaccTransGetReadOnly(Transaction * trans) -> char const *"""
    return _gnucash_core_c.xaccTransGetReadOnly(trans)

def xaccTransIsReadonlyByPostedDate(trans):
    r"""xaccTransIsReadonlyByPostedDate(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransIsReadonlyByPostedDate(trans)

def xaccTransCountSplits(trans):
    r"""xaccTransCountSplits(Transaction const * trans) -> int"""
    return _gnucash_core_c.xaccTransCountSplits(trans)

def xaccTransHasReconciledSplits(trans):
    r"""xaccTransHasReconciledSplits(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransHasReconciledSplits(trans)

def xaccTransHasReconciledSplitsByAccount(trans, account):
    r"""xaccTransHasReconciledSplitsByAccount(Transaction const * trans, Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccTransHasReconciledSplitsByAccount(trans, account)

def xaccTransHasSplitsInState(trans, state):
    r"""xaccTransHasSplitsInState(Transaction const * trans, char const state) -> gboolean"""
    return _gnucash_core_c.xaccTransHasSplitsInState(trans, state)

def xaccTransHasSplitsInStateByAccount(trans, state, account):
    r"""xaccTransHasSplitsInStateByAccount(Transaction const * trans, char const state, Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccTransHasSplitsInStateByAccount(trans, state, account)

def xaccTransGetCurrency(trans):
    r"""xaccTransGetCurrency(Transaction const * trans) -> gnc_commodity *"""
    return _gnucash_core_c.xaccTransGetCurrency(trans)

def xaccTransSetCurrency(trans, curr):
    r"""xaccTransSetCurrency(Transaction * trans, gnc_commodity * curr)"""
    return _gnucash_core_c.xaccTransSetCurrency(trans, curr)

def xaccTransGetImbalanceValue(trans):
    r"""xaccTransGetImbalanceValue(Transaction const * trans) -> _gnc_numeric"""
    return _gnucash_core_c.xaccTransGetImbalanceValue(trans)

def xaccTransGetImbalance(trans):
    r"""xaccTransGetImbalance(Transaction const * trans) -> MonetaryList *"""
    return _gnucash_core_c.xaccTransGetImbalance(trans)

def xaccTransIsBalanced(trans):
    r"""xaccTransIsBalanced(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransIsBalanced(trans)

def xaccTransGetAccountValue(trans, account):
    r"""xaccTransGetAccountValue(Transaction const * trans, Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccTransGetAccountValue(trans, account)

def xaccTransGetAccountAmount(trans, account):
    r"""xaccTransGetAccountAmount(Transaction const * trans, Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccTransGetAccountAmount(trans, account)

def xaccTransGetAccountConvRate(txn, acc):
    r"""xaccTransGetAccountConvRate(Transaction const * txn, Account const * acc) -> _gnc_numeric"""
    return _gnucash_core_c.xaccTransGetAccountConvRate(txn, acc)

def xaccTransGetAccountBalance(trans, account):
    r"""xaccTransGetAccountBalance(Transaction const * trans, Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccTransGetAccountBalance(trans, account)

def xaccTransOrder(ta, tb):
    r"""xaccTransOrder(Transaction const * ta, Transaction const * tb) -> int"""
    return _gnucash_core_c.xaccTransOrder(ta, tb)

def xaccTransOrder_num_action(ta, actna, tb, actnb):
    r"""xaccTransOrder_num_action(Transaction const * ta, char const * actna, Transaction const * tb, char const * actnb) -> int"""
    return _gnucash_core_c.xaccTransOrder_num_action(ta, actna, tb, actnb)

def xaccTransSetDate(trans, day, mon, year):
    r"""xaccTransSetDate(Transaction * trans, int day, int mon, int year)"""
    return _gnucash_core_c.xaccTransSetDate(trans, day, mon, year)

def xaccTransSetDatePostedGDate(trans, date):
    r"""xaccTransSetDatePostedGDate(Transaction * trans, GDate date)"""
    return _gnucash_core_c.xaccTransSetDatePostedGDate(trans, date)

def xaccTransSetDatePostedSecs(trans, time):
    r"""xaccTransSetDatePostedSecs(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDatePostedSecs(trans, time)

def xaccTransSetDatePostedSecsNormalized(trans, time):
    r"""xaccTransSetDatePostedSecsNormalized(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDatePostedSecsNormalized(trans, time)

def xaccTransSetDateEnteredSecs(trans, time):
    r"""xaccTransSetDateEnteredSecs(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDateEnteredSecs(trans, time)

def xaccTransSetDateDue(trans, time):
    r"""xaccTransSetDateDue(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDateDue(trans, time)

def xaccTransGetDate(trans):
    r"""xaccTransGetDate(Transaction const * trans) -> time64"""
    return _gnucash_core_c.xaccTransGetDate(trans)

def xaccTransRetDatePosted(trans):
    r"""xaccTransRetDatePosted(Transaction const * trans) -> time64"""
    return _gnucash_core_c.xaccTransRetDatePosted(trans)

def xaccTransGetDatePostedGDate(trans):
    r"""xaccTransGetDatePostedGDate(Transaction const * trans) -> GDate"""
    return _gnucash_core_c.xaccTransGetDatePostedGDate(trans)

def xaccTransGetDateEntered(trans):
    r"""xaccTransGetDateEntered(Transaction const * trans) -> time64"""
    return _gnucash_core_c.xaccTransGetDateEntered(trans)

def xaccTransRetDateEntered(trans):
    r"""xaccTransRetDateEntered(Transaction const * trans) -> time64"""
    return _gnucash_core_c.xaccTransRetDateEntered(trans)

def xaccTransRetDateDue(trans):
    r"""xaccTransRetDateDue(Transaction const * trans) -> time64"""
    return _gnucash_core_c.xaccTransRetDateDue(trans)

def xaccTransVoid(transaction, reason):
    r"""xaccTransVoid(Transaction * transaction, char const * reason)"""
    return _gnucash_core_c.xaccTransVoid(transaction, reason)

def xaccTransUnvoid(transaction):
    r"""xaccTransUnvoid(Transaction * transaction)"""
    return _gnucash_core_c.xaccTransUnvoid(transaction)

def xaccTransReverse(transaction):
    r"""xaccTransReverse(Transaction * transaction) -> Transaction *"""
    return _gnucash_core_c.xaccTransReverse(transaction)

def xaccTransGetReversedBy(trans):
    r"""xaccTransGetReversedBy(Transaction const * trans) -> Transaction *"""
    return _gnucash_core_c.xaccTransGetReversedBy(trans)

def xaccTransGetVoidStatus(transaction):
    r"""xaccTransGetVoidStatus(Transaction const * transaction) -> gboolean"""
    return _gnucash_core_c.xaccTransGetVoidStatus(transaction)

def xaccTransGetVoidReason(transaction):
    r"""xaccTransGetVoidReason(Transaction const * transaction) -> char const *"""
    return _gnucash_core_c.xaccTransGetVoidReason(transaction)

def xaccTransGetVoidTime(tr):
    r"""xaccTransGetVoidTime(Transaction const * tr) -> time64"""
    return _gnucash_core_c.xaccTransGetVoidTime(tr)
TRANS_KVP = _gnucash_core_c.TRANS_KVP

TRANS_NUM = _gnucash_core_c.TRANS_NUM

TRANS_DESCRIPTION = _gnucash_core_c.TRANS_DESCRIPTION

TRANS_DATE_ENTERED = _gnucash_core_c.TRANS_DATE_ENTERED

TRANS_DATE_POSTED = _gnucash_core_c.TRANS_DATE_POSTED

TRANS_DATE_DUE = _gnucash_core_c.TRANS_DATE_DUE

TRANS_IMBALANCE = _gnucash_core_c.TRANS_IMBALANCE

TRANS_IS_BALANCED = _gnucash_core_c.TRANS_IS_BALANCED

TRANS_IS_CLOSING = _gnucash_core_c.TRANS_IS_CLOSING

TRANS_NOTES = _gnucash_core_c.TRANS_NOTES

TRANS_DOCLINK = _gnucash_core_c.TRANS_DOCLINK

TRANS_TYPE = _gnucash_core_c.TRANS_TYPE

TRANS_VOID_STATUS = _gnucash_core_c.TRANS_VOID_STATUS

TRANS_VOID_REASON = _gnucash_core_c.TRANS_VOID_REASON

TRANS_VOID_TIME = _gnucash_core_c.TRANS_VOID_TIME

TRANS_SPLITLIST = _gnucash_core_c.TRANS_SPLITLIST


def xaccTransRecordPrice(trans, source):
    r"""xaccTransRecordPrice(Transaction * trans, PriceSource source)"""
    return _gnucash_core_c.xaccTransRecordPrice(trans, source)
RECONCILED_MATCH_TYPE = _gnucash_core_c.RECONCILED_MATCH_TYPE

class GncLotClass(object):
    r"""Proxy of C GncLotClass struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    parent_class = property(_gnucash_core_c.GncLotClass_parent_class_get, _gnucash_core_c.GncLotClass_parent_class_set, doc=r"""parent_class : QofInstanceClass""")

    def __init__(self):
        r"""__init__(GncLotClass self) -> GncLotClass"""
        _gnucash_core_c.GncLotClass_swiginit(self, _gnucash_core_c.new_GncLotClass())
    __swig_destroy__ = _gnucash_core_c.delete_GncLotClass

# Register GncLotClass in _gnucash_core_c:
_gnucash_core_c.GncLotClass_swigregister(GncLotClass)

def gnc_lot_get_type():
    r"""gnc_lot_get_type() -> GType"""
    return _gnucash_core_c.gnc_lot_get_type()

def gnc_lot_new(arg1):
    r"""gnc_lot_new(QofBook * arg1) -> GNCLot *"""
    return _gnucash_core_c.gnc_lot_new(arg1)

def gnc_lot_destroy(arg1):
    r"""gnc_lot_destroy(GNCLot * arg1)"""
    return _gnucash_core_c.gnc_lot_destroy(arg1)

def gnc_lot_lookup(guid, book):
    r"""gnc_lot_lookup(GncGUID guid, QofBook * book) -> GNCLot *"""
    return _gnucash_core_c.gnc_lot_lookup(guid, book)

def gnc_lot_get_book(arg1):
    r"""gnc_lot_get_book(GNCLot * arg1) -> QofBook *"""
    return _gnucash_core_c.gnc_lot_get_book(arg1)

def gnc_lot_begin_edit(lot):
    r"""gnc_lot_begin_edit(GNCLot * lot)"""
    return _gnucash_core_c.gnc_lot_begin_edit(lot)

def gnc_lot_commit_edit(lot):
    r"""gnc_lot_commit_edit(GNCLot * lot)"""
    return _gnucash_core_c.gnc_lot_commit_edit(lot)

def gnc_lot_add_split(arg1, arg2):
    r"""gnc_lot_add_split(GNCLot * arg1, Split * arg2)"""
    return _gnucash_core_c.gnc_lot_add_split(arg1, arg2)

def gnc_lot_remove_split(arg1, arg2):
    r"""gnc_lot_remove_split(GNCLot * arg1, Split * arg2)"""
    return _gnucash_core_c.gnc_lot_remove_split(arg1, arg2)

def gnc_lot_get_split_list(arg1):
    r"""gnc_lot_get_split_list(GNCLot const * arg1) -> SplitList *"""
    return _gnucash_core_c.gnc_lot_get_split_list(arg1)

def gnc_lot_count_splits(arg1):
    r"""gnc_lot_count_splits(GNCLot const * arg1) -> gint"""
    return _gnucash_core_c.gnc_lot_count_splits(arg1)

def gnc_lot_get_account(arg1):
    r"""gnc_lot_get_account(GNCLot const * arg1) -> Account *"""
    return _gnucash_core_c.gnc_lot_get_account(arg1)

def gnc_lot_set_account(arg1, arg2):
    r"""gnc_lot_set_account(GNCLot * arg1, Account * arg2)"""
    return _gnucash_core_c.gnc_lot_set_account(arg1, arg2)

def gnc_lot_get_cached_invoice(lot):
    r"""gnc_lot_get_cached_invoice(GNCLot const * lot) -> GncInvoice *"""
    return _gnucash_core_c.gnc_lot_get_cached_invoice(lot)

def gnc_lot_set_cached_invoice(lot, invoice):
    r"""gnc_lot_set_cached_invoice(GNCLot * lot, GncInvoice * invoice)"""
    return _gnucash_core_c.gnc_lot_set_cached_invoice(lot, invoice)

def gnc_lot_get_balance(arg1):
    r"""gnc_lot_get_balance(GNCLot * arg1) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_lot_get_balance(arg1)

def gnc_lot_get_balance_before(arg1, arg2, arg3, arg4):
    r"""gnc_lot_get_balance_before(GNCLot const * arg1, Split const * arg2, _gnc_numeric arg3, _gnc_numeric arg4)"""
    return _gnucash_core_c.gnc_lot_get_balance_before(arg1, arg2, arg3, arg4)

def gnc_lot_is_closed(arg1):
    r"""gnc_lot_is_closed(GNCLot * arg1) -> gboolean"""
    return _gnucash_core_c.gnc_lot_is_closed(arg1)

def gnc_lot_get_earliest_split(lot):
    r"""gnc_lot_get_earliest_split(GNCLot * lot) -> Split *"""
    return _gnucash_core_c.gnc_lot_get_earliest_split(lot)

def gnc_lot_get_latest_split(lot):
    r"""gnc_lot_get_latest_split(GNCLot * lot) -> Split *"""
    return _gnucash_core_c.gnc_lot_get_latest_split(lot)

def gnc_lot_set_closed_unknown(arg1):
    r"""gnc_lot_set_closed_unknown(GNCLot * arg1)"""
    return _gnucash_core_c.gnc_lot_set_closed_unknown(arg1)

def gnc_lot_get_title(arg1):
    r"""gnc_lot_get_title(GNCLot const * arg1) -> char const *"""
    return _gnucash_core_c.gnc_lot_get_title(arg1)

def gnc_lot_get_notes(arg1):
    r"""gnc_lot_get_notes(GNCLot const * arg1) -> char const *"""
    return _gnucash_core_c.gnc_lot_get_notes(arg1)

def gnc_lot_set_title(arg1, arg2):
    r"""gnc_lot_set_title(GNCLot * arg1, char const * arg2)"""
    return _gnucash_core_c.gnc_lot_set_title(arg1, arg2)

def gnc_lot_set_notes(arg1, arg2):
    r"""gnc_lot_set_notes(GNCLot * arg1, char const * arg2)"""
    return _gnucash_core_c.gnc_lot_set_notes(arg1, arg2)

def gnc_lot_make_default(acc):
    r"""gnc_lot_make_default(Account * acc) -> GNCLot *"""
    return _gnucash_core_c.gnc_lot_make_default(acc)
LOT_IS_CLOSED = _gnucash_core_c.LOT_IS_CLOSED

LOT_BALANCE = _gnucash_core_c.LOT_BALANCE

LOT_TITLE = _gnucash_core_c.LOT_TITLE

LOT_NOTES = _gnucash_core_c.LOT_NOTES

QOF_MOD_BACKEND = _gnucash_core_c.QOF_MOD_BACKEND

ERR_BACKEND_NO_ERR = _gnucash_core_c.ERR_BACKEND_NO_ERR

ERR_BACKEND_NO_HANDLER = _gnucash_core_c.ERR_BACKEND_NO_HANDLER

ERR_BACKEND_NO_BACKEND = _gnucash_core_c.ERR_BACKEND_NO_BACKEND

ERR_BACKEND_BAD_URL = _gnucash_core_c.ERR_BACKEND_BAD_URL

ERR_BACKEND_NO_SUCH_DB = _gnucash_core_c.ERR_BACKEND_NO_SUCH_DB

ERR_BACKEND_CANT_CONNECT = _gnucash_core_c.ERR_BACKEND_CANT_CONNECT

ERR_BACKEND_CONN_LOST = _gnucash_core_c.ERR_BACKEND_CONN_LOST

ERR_BACKEND_LOCKED = _gnucash_core_c.ERR_BACKEND_LOCKED

ERR_BACKEND_STORE_EXISTS = _gnucash_core_c.ERR_BACKEND_STORE_EXISTS

ERR_BACKEND_READONLY = _gnucash_core_c.ERR_BACKEND_READONLY

ERR_BACKEND_TOO_NEW = _gnucash_core_c.ERR_BACKEND_TOO_NEW

ERR_BACKEND_DATA_CORRUPT = _gnucash_core_c.ERR_BACKEND_DATA_CORRUPT

ERR_BACKEND_SERVER_ERR = _gnucash_core_c.ERR_BACKEND_SERVER_ERR

ERR_BACKEND_ALLOC = _gnucash_core_c.ERR_BACKEND_ALLOC

ERR_BACKEND_PERM = _gnucash_core_c.ERR_BACKEND_PERM

ERR_BACKEND_MODIFIED = _gnucash_core_c.ERR_BACKEND_MODIFIED

ERR_BACKEND_MOD_DESTROY = _gnucash_core_c.ERR_BACKEND_MOD_DESTROY

ERR_BACKEND_MISC = _gnucash_core_c.ERR_BACKEND_MISC

ERR_QOF_OVERFLOW = _gnucash_core_c.ERR_QOF_OVERFLOW

ERR_FILEIO_FILE_BAD_READ = _gnucash_core_c.ERR_FILEIO_FILE_BAD_READ

ERR_FILEIO_FILE_EMPTY = _gnucash_core_c.ERR_FILEIO_FILE_EMPTY

ERR_FILEIO_FILE_LOCKERR = _gnucash_core_c.ERR_FILEIO_FILE_LOCKERR

ERR_FILEIO_FILE_NOT_FOUND = _gnucash_core_c.ERR_FILEIO_FILE_NOT_FOUND

ERR_FILEIO_FILE_TOO_OLD = _gnucash_core_c.ERR_FILEIO_FILE_TOO_OLD

ERR_FILEIO_UNKNOWN_FILE_TYPE = _gnucash_core_c.ERR_FILEIO_UNKNOWN_FILE_TYPE

ERR_FILEIO_PARSE_ERROR = _gnucash_core_c.ERR_FILEIO_PARSE_ERROR

ERR_FILEIO_BACKUP_ERROR = _gnucash_core_c.ERR_FILEIO_BACKUP_ERROR

ERR_FILEIO_WRITE_ERROR = _gnucash_core_c.ERR_FILEIO_WRITE_ERROR

ERR_FILEIO_READ_ERROR = _gnucash_core_c.ERR_FILEIO_READ_ERROR

ERR_FILEIO_NO_ENCODING = _gnucash_core_c.ERR_FILEIO_NO_ENCODING

ERR_FILEIO_FILE_EACCES = _gnucash_core_c.ERR_FILEIO_FILE_EACCES

ERR_FILEIO_RESERVED_WRITE = _gnucash_core_c.ERR_FILEIO_RESERVED_WRITE

ERR_FILEIO_FILE_UPGRADE = _gnucash_core_c.ERR_FILEIO_FILE_UPGRADE

ERR_NETIO_SHORT_READ = _gnucash_core_c.ERR_NETIO_SHORT_READ

ERR_NETIO_WRONG_CONTENT_TYPE = _gnucash_core_c.ERR_NETIO_WRONG_CONTENT_TYPE

ERR_NETIO_NOT_GNCXML = _gnucash_core_c.ERR_NETIO_NOT_GNCXML

ERR_SQL_MISSING_DATA = _gnucash_core_c.ERR_SQL_MISSING_DATA

ERR_SQL_DB_TOO_OLD = _gnucash_core_c.ERR_SQL_DB_TOO_OLD

ERR_SQL_DB_TOO_NEW = _gnucash_core_c.ERR_SQL_DB_TOO_NEW

ERR_SQL_DB_BUSY = _gnucash_core_c.ERR_SQL_DB_BUSY

ERR_SQL_BAD_DBI = _gnucash_core_c.ERR_SQL_BAD_DBI

ERR_SQL_DBI_UNTESTABLE = _gnucash_core_c.ERR_SQL_DBI_UNTESTABLE

ERR_RPC_HOST_UNK = _gnucash_core_c.ERR_RPC_HOST_UNK

ERR_RPC_CANT_BIND = _gnucash_core_c.ERR_RPC_CANT_BIND

ERR_RPC_CANT_ACCEPT = _gnucash_core_c.ERR_RPC_CANT_ACCEPT

ERR_RPC_NO_CONNECTION = _gnucash_core_c.ERR_RPC_NO_CONNECTION

ERR_RPC_BAD_VERSION = _gnucash_core_c.ERR_RPC_BAD_VERSION

ERR_RPC_FAILED = _gnucash_core_c.ERR_RPC_FAILED

ERR_RPC_NOT_ADDED = _gnucash_core_c.ERR_RPC_NOT_ADDED


def qof_backend_get_error(arg1):
    r"""qof_backend_get_error(QofBackend * arg1) -> QofBackendError"""
    return _gnucash_core_c.qof_backend_get_error(arg1)

def qof_backend_set_error(arg1, arg2):
    r"""qof_backend_set_error(QofBackend * arg1, QofBackendError arg2)"""
    return _gnucash_core_c.qof_backend_set_error(arg1, arg2)

def qof_backend_can_rollback(arg1):
    r"""qof_backend_can_rollback(QofBackend * arg1) -> gboolean"""
    return _gnucash_core_c.qof_backend_can_rollback(arg1)

def qof_backend_rollback_instance(arg1, arg2):
    r"""qof_backend_rollback_instance(QofBackend * arg1, QofInstance * arg2)"""
    return _gnucash_core_c.qof_backend_rollback_instance(arg1, arg2)

def qof_load_backend_library(directory, module_name):
    r"""qof_load_backend_library(gchar const * directory, gchar const * module_name) -> gboolean"""
    return _gnucash_core_c.qof_load_backend_library(directory, module_name)

def qof_finalize_backend_libraries():
    r"""qof_finalize_backend_libraries()"""
    return _gnucash_core_c.qof_finalize_backend_libraries()

def qof_book_get_backend(book):
    r"""qof_book_get_backend(QofBook const * book) -> QofBackend *"""
    return _gnucash_core_c.qof_book_get_backend(book)

def qof_book_set_backend(book, arg2):
    r"""qof_book_set_backend(QofBook * book, QofBackend * arg2)"""
    return _gnucash_core_c.qof_book_set_backend(book, arg2)
QOF_MOD_SESSION = _gnucash_core_c.QOF_MOD_SESSION

SESSION_NORMAL_OPEN = _gnucash_core_c.SESSION_NORMAL_OPEN

SESSION_NEW_STORE = _gnucash_core_c.SESSION_NEW_STORE

SESSION_NEW_OVERWRITE = _gnucash_core_c.SESSION_NEW_OVERWRITE

SESSION_READ_ONLY = _gnucash_core_c.SESSION_READ_ONLY

SESSION_BREAK_LOCK = _gnucash_core_c.SESSION_BREAK_LOCK


def qof_session_new(book):
    r"""qof_session_new(QofBook * book) -> QofSession *"""
    return _gnucash_core_c.qof_session_new(book)

def qof_session_destroy(session):
    r"""qof_session_destroy(QofSession * session)"""
    return _gnucash_core_c.qof_session_destroy(session)

def qof_session_swap_data(session_1, session_2):
    r"""qof_session_swap_data(QofSession * session_1, QofSession * session_2)"""
    return _gnucash_core_c.qof_session_swap_data(session_1, session_2)

def qof_session_begin(session, new_uri, mode):
    r"""qof_session_begin(QofSession * session, char const * new_uri, SessionOpenMode mode)"""
    return _gnucash_core_c.qof_session_begin(session, new_uri, mode)

def qof_session_load(session, percentage_func):
    r"""qof_session_load(QofSession * session, QofPercentageFunc percentage_func)"""
    return _gnucash_core_c.qof_session_load(session, percentage_func)

def qof_session_get_error(session):
    r"""qof_session_get_error(QofSession * session) -> QofBackendError"""
    return _gnucash_core_c.qof_session_get_error(session)

def qof_session_get_error_message(session):
    r"""qof_session_get_error_message(QofSession const * session) -> char const *"""
    return _gnucash_core_c.qof_session_get_error_message(session)

def qof_session_pop_error(session):
    r"""qof_session_pop_error(QofSession * session) -> QofBackendError"""
    return _gnucash_core_c.qof_session_pop_error(session)

def qof_session_get_book(session):
    r"""qof_session_get_book(QofSession const * session) -> QofBook *"""
    return _gnucash_core_c.qof_session_get_book(session)

def qof_session_get_file_path(session):
    r"""qof_session_get_file_path(QofSession const * session) -> char const *"""
    return _gnucash_core_c.qof_session_get_file_path(session)

def qof_session_get_url(session):
    r"""qof_session_get_url(QofSession const * session) -> char const *"""
    return _gnucash_core_c.qof_session_get_url(session)

def qof_session_save_in_progress(session):
    r"""qof_session_save_in_progress(QofSession const * session) -> gboolean"""
    return _gnucash_core_c.qof_session_save_in_progress(session)

def qof_session_get_backend(session):
    r"""qof_session_get_backend(QofSession const * session) -> QofBackend *"""
    return _gnucash_core_c.qof_session_get_backend(session)

def qof_session_save(session, percentage_func):
    r"""qof_session_save(QofSession * session, QofPercentageFunc percentage_func)"""
    return _gnucash_core_c.qof_session_save(session, percentage_func)

def qof_session_safe_save(session, percentage_func):
    r"""qof_session_safe_save(QofSession * session, QofPercentageFunc percentage_func)"""
    return _gnucash_core_c.qof_session_safe_save(session, percentage_func)

def qof_session_end(session):
    r"""qof_session_end(QofSession * session)"""
    return _gnucash_core_c.qof_session_end(session)

def qof_session_events_pending(session):
    r"""qof_session_events_pending(QofSession const * session) -> gboolean"""
    return _gnucash_core_c.qof_session_events_pending(session)

def qof_session_process_events(session):
    r"""qof_session_process_events(QofSession * session) -> gboolean"""
    return _gnucash_core_c.qof_session_process_events(session)

def qof_session_export(tmp_session, real_session, percentage_func):
    r"""qof_session_export(QofSession * tmp_session, QofSession * real_session, QofPercentageFunc percentage_func) -> gboolean"""
    return _gnucash_core_c.qof_session_export(tmp_session, real_session, percentage_func)

def qof_backend_get_registered_access_method_list():
    r"""qof_backend_get_registered_access_method_list() -> GList *"""
    return _gnucash_core_c.qof_backend_get_registered_access_method_list()

def qof_session_ensure_all_data_loaded(session):
    r"""qof_session_ensure_all_data_loaded(QofSession * session)"""
    return _gnucash_core_c.qof_session_ensure_all_data_loaded(session)

def qof_book_use_trading_accounts(book):
    r"""qof_book_use_trading_accounts(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_use_trading_accounts(book)

def qof_book_reset_num_days_autoreadonly_cache(book):
    r"""qof_book_reset_num_days_autoreadonly_cache(QofBook * book)"""
    return _gnucash_core_c.qof_book_reset_num_days_autoreadonly_cache(book)

def qof_book_uses_autoreadonly(book):
    r"""qof_book_uses_autoreadonly(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_uses_autoreadonly(book)

def qof_book_get_num_days_autoreadonly(book):
    r"""qof_book_get_num_days_autoreadonly(QofBook const * book) -> gint"""
    return _gnucash_core_c.qof_book_get_num_days_autoreadonly(book)

def qof_book_get_autoreadonly_gdate(book):
    r"""qof_book_get_autoreadonly_gdate(QofBook const * book) -> GDate *"""
    return _gnucash_core_c.qof_book_get_autoreadonly_gdate(book)

def qof_book_set_default_invoice_report(book, guid, name):
    r"""qof_book_set_default_invoice_report(QofBook * book, gchar const * guid, gchar const * name)"""
    return _gnucash_core_c.qof_book_set_default_invoice_report(book, guid, name)

def qof_book_get_default_invoice_report_guid(book):
    r"""qof_book_get_default_invoice_report_guid(QofBook const * book) -> gchar *"""
    return _gnucash_core_c.qof_book_get_default_invoice_report_guid(book)

def qof_book_get_default_invoice_report_name(book):
    r"""qof_book_get_default_invoice_report_name(QofBook const * book) -> gchar *"""
    return _gnucash_core_c.qof_book_get_default_invoice_report_name(book)

def qof_book_get_default_invoice_report_timeout(book):
    r"""qof_book_get_default_invoice_report_timeout(QofBook const * book) -> gdouble"""
    return _gnucash_core_c.qof_book_get_default_invoice_report_timeout(book)

def qof_book_use_split_action_for_num_field(book):
    r"""qof_book_use_split_action_for_num_field(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_use_split_action_for_num_field(book)

def qof_book_shutting_down(book):
    r"""qof_book_shutting_down(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_shutting_down(book)

def qof_book_session_not_saved(book):
    r"""qof_book_session_not_saved(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_session_not_saved(book)
QOF_ID_NULL = _gnucash_core_c.QOF_ID_NULL

QOF_ID_BOOK = _gnucash_core_c.QOF_ID_BOOK

QOF_ID_SESSION = _gnucash_core_c.QOF_ID_SESSION


def qof_collection_new(type):
    r"""qof_collection_new(QofIdType type) -> QofCollection *"""
    return _gnucash_core_c.qof_collection_new(type)

def qof_collection_count(col):
    r"""qof_collection_count(QofCollection const * col) -> guint"""
    return _gnucash_core_c.qof_collection_count(col)

def qof_collection_destroy(col):
    r"""qof_collection_destroy(QofCollection * col)"""
    return _gnucash_core_c.qof_collection_destroy(col)

def qof_collection_get_type(arg1):
    r"""qof_collection_get_type(QofCollection const * arg1) -> QofIdType"""
    return _gnucash_core_c.qof_collection_get_type(arg1)

def qof_collection_lookup_entity(arg1, arg2):
    r"""qof_collection_lookup_entity(QofCollection const * arg1, GncGUID arg2) -> QofInstance *"""
    return _gnucash_core_c.qof_collection_lookup_entity(arg1, arg2)

def qof_collection_foreach_sorted(col, cb_func, user_data, sort_fn):
    r"""qof_collection_foreach_sorted(QofCollection const * col, QofInstanceForeachCB cb_func, gpointer user_data, GCompareFunc sort_fn)"""
    return _gnucash_core_c.qof_collection_foreach_sorted(col, cb_func, user_data, sort_fn)

def qof_collection_foreach(arg1, arg2, user_data):
    r"""qof_collection_foreach(QofCollection const * arg1, QofInstanceForeachCB arg2, gpointer user_data)"""
    return _gnucash_core_c.qof_collection_foreach(arg1, arg2, user_data)

def qof_collection_get_data(col):
    r"""qof_collection_get_data(QofCollection const * col) -> gpointer"""
    return _gnucash_core_c.qof_collection_get_data(col)

def qof_collection_set_data(col, user_data):
    r"""qof_collection_set_data(QofCollection * col, gpointer user_data)"""
    return _gnucash_core_c.qof_collection_set_data(col, user_data)

def qof_collection_is_dirty(col):
    r"""qof_collection_is_dirty(QofCollection const * col) -> gboolean"""
    return _gnucash_core_c.qof_collection_is_dirty(col)

def qof_collection_add_entity(coll, ent):
    r"""qof_collection_add_entity(QofCollection * coll, QofInstance * ent) -> gboolean"""
    return _gnucash_core_c.qof_collection_add_entity(coll, ent)

def qof_collection_remove_entity(ent):
    r"""qof_collection_remove_entity(QofInstance * ent)"""
    return _gnucash_core_c.qof_collection_remove_entity(ent)

def qof_collection_compare(target, merge):
    r"""qof_collection_compare(QofCollection * target, QofCollection * merge) -> gint"""
    return _gnucash_core_c.qof_collection_compare(target, merge)
QOF_MOD_QUERY = _gnucash_core_c.QOF_MOD_QUERY

QOF_QUERY_AND = _gnucash_core_c.QOF_QUERY_AND

QOF_QUERY_OR = _gnucash_core_c.QOF_QUERY_OR

QOF_QUERY_NAND = _gnucash_core_c.QOF_QUERY_NAND

QOF_QUERY_NOR = _gnucash_core_c.QOF_QUERY_NOR

QOF_QUERY_XOR = _gnucash_core_c.QOF_QUERY_XOR

QUERY_DEFAULT_SORT = _gnucash_core_c.QUERY_DEFAULT_SORT

QOF_PARAM_BOOK = _gnucash_core_c.QOF_PARAM_BOOK

QOF_PARAM_GUID = _gnucash_core_c.QOF_PARAM_GUID

QOF_PARAM_KVP = _gnucash_core_c.QOF_PARAM_KVP

QOF_PARAM_ACTIVE = _gnucash_core_c.QOF_PARAM_ACTIVE

QOF_PARAM_VERSION = _gnucash_core_c.QOF_PARAM_VERSION


def qof_query_init():
    r"""qof_query_init()"""
    return _gnucash_core_c.qof_query_init()

def qof_query_shutdown():
    r"""qof_query_shutdown()"""
    return _gnucash_core_c.qof_query_shutdown()

def qof_query_build_param_list(*args):
    r"""qof_query_build_param_list(char const * param) -> QofQueryParamList *"""
    return _gnucash_core_c.qof_query_build_param_list(*args)

def qof_query_create():
    r"""qof_query_create() -> QofQuery *"""
    return _gnucash_core_c.qof_query_create()

def qof_query_create_for(obj_type):
    r"""qof_query_create_for(QofIdTypeConst obj_type) -> QofQuery *"""
    return _gnucash_core_c.qof_query_create_for(obj_type)

def qof_query_destroy(q):
    r"""qof_query_destroy(QofQuery * q)"""
    return _gnucash_core_c.qof_query_destroy(q)

def qof_query_search_for(query, obj_type):
    r"""qof_query_search_for(QofQuery * query, QofIdTypeConst obj_type)"""
    return _gnucash_core_c.qof_query_search_for(query, obj_type)

def qof_query_set_book(q, book):
    r"""qof_query_set_book(QofQuery * q, QofBook * book)"""
    return _gnucash_core_c.qof_query_set_book(q, book)

def qof_query_add_term(query, param_list, pred_data, op):
    r"""qof_query_add_term(QofQuery * query, QofQueryParamList * param_list, _QofQueryPredData pred_data, QofQueryOp op)"""
    return _gnucash_core_c.qof_query_add_term(query, param_list, pred_data, op)

def qof_query_add_guid_match(q, param_list, guid, op):
    r"""qof_query_add_guid_match(QofQuery * q, QofQueryParamList * param_list, GncGUID guid, QofQueryOp op)"""
    return _gnucash_core_c.qof_query_add_guid_match(q, param_list, guid, op)

def qof_query_add_guid_list_match(q, param_list, guid_list, options, op):
    r"""qof_query_add_guid_list_match(QofQuery * q, QofQueryParamList * param_list, GList * guid_list, QofGuidMatch options, QofQueryOp op)"""
    return _gnucash_core_c.qof_query_add_guid_list_match(q, param_list, guid_list, options, op)

def qof_query_add_boolean_match(q, param_list, value, op):
    r"""qof_query_add_boolean_match(QofQuery * q, QofQueryParamList * param_list, gboolean value, QofQueryOp op)"""
    return _gnucash_core_c.qof_query_add_boolean_match(q, param_list, value, op)

def qof_query_run(query):
    r"""qof_query_run(QofQuery * query) -> GList *"""
    return _gnucash_core_c.qof_query_run(query)

def qof_query_last_run(query):
    r"""qof_query_last_run(QofQuery * query) -> GList *"""
    return _gnucash_core_c.qof_query_last_run(query)

def qof_query_run_subquery(subquery, primary_query):
    r"""qof_query_run_subquery(QofQuery * subquery, QofQuery const * primary_query) -> GList *"""
    return _gnucash_core_c.qof_query_run_subquery(subquery, primary_query)

def qof_query_clear(query):
    r"""qof_query_clear(QofQuery * query)"""
    return _gnucash_core_c.qof_query_clear(query)

def qof_query_purge_terms(q, param_list):
    r"""qof_query_purge_terms(QofQuery * q, QofQueryParamList * param_list)"""
    return _gnucash_core_c.qof_query_purge_terms(q, param_list)

def qof_query_has_terms(q):
    r"""qof_query_has_terms(QofQuery * q) -> int"""
    return _gnucash_core_c.qof_query_has_terms(q)

def qof_query_num_terms(q):
    r"""qof_query_num_terms(QofQuery * q) -> int"""
    return _gnucash_core_c.qof_query_num_terms(q)

def qof_query_has_term_type(q, term_param):
    r"""qof_query_has_term_type(QofQuery * q, QofQueryParamList * term_param) -> gboolean"""
    return _gnucash_core_c.qof_query_has_term_type(q, term_param)

def qof_query_get_term_type(q, term_param):
    r"""qof_query_get_term_type(QofQuery * q, QofQueryParamList * term_param) -> GSList *"""
    return _gnucash_core_c.qof_query_get_term_type(q, term_param)

def qof_query_copy(q):
    r"""qof_query_copy(QofQuery * q) -> QofQuery *"""
    return _gnucash_core_c.qof_query_copy(q)

def qof_query_invert(q):
    r"""qof_query_invert(QofQuery * q) -> QofQuery *"""
    return _gnucash_core_c.qof_query_invert(q)

def qof_query_merge(q1, q2, op):
    r"""qof_query_merge(QofQuery * q1, QofQuery * q2, QofQueryOp op) -> QofQuery *"""
    return _gnucash_core_c.qof_query_merge(q1, q2, op)

def qof_query_merge_in_place(q1, q2, op):
    r"""qof_query_merge_in_place(QofQuery * q1, QofQuery * q2, QofQueryOp op)"""
    return _gnucash_core_c.qof_query_merge_in_place(q1, q2, op)

def qof_query_set_sort_order(q, primary_sort_params, secondary_sort_params, tertiary_sort_params):
    r"""qof_query_set_sort_order(QofQuery * q, QofQueryParamList * primary_sort_params, QofQueryParamList * secondary_sort_params, QofQueryParamList * tertiary_sort_params)"""
    return _gnucash_core_c.qof_query_set_sort_order(q, primary_sort_params, secondary_sort_params, tertiary_sort_params)

def qof_query_set_sort_options(q, prim_op, sec_op, tert_op):
    r"""qof_query_set_sort_options(QofQuery * q, gint prim_op, gint sec_op, gint tert_op)"""
    return _gnucash_core_c.qof_query_set_sort_options(q, prim_op, sec_op, tert_op)

def qof_query_set_sort_increasing(q, prim_inc, sec_inc, tert_inc):
    r"""qof_query_set_sort_increasing(QofQuery * q, gboolean prim_inc, gboolean sec_inc, gboolean tert_inc)"""
    return _gnucash_core_c.qof_query_set_sort_increasing(q, prim_inc, sec_inc, tert_inc)

def qof_query_set_max_results(q, n):
    r"""qof_query_set_max_results(QofQuery * q, int n)"""
    return _gnucash_core_c.qof_query_set_max_results(q, n)

def qof_query_equal(q1, q2):
    r"""qof_query_equal(QofQuery const * q1, QofQuery const * q2) -> gboolean"""
    return _gnucash_core_c.qof_query_equal(q1, q2)

def qof_query_get_search_for(q):
    r"""qof_query_get_search_for(QofQuery const * q) -> QofIdType"""
    return _gnucash_core_c.qof_query_get_search_for(q)

def qof_query_get_books(q):
    r"""qof_query_get_books(QofQuery * q) -> GList *"""
    return _gnucash_core_c.qof_query_get_books(q)
QOF_COMPARE_LT = _gnucash_core_c.QOF_COMPARE_LT

QOF_COMPARE_LTE = _gnucash_core_c.QOF_COMPARE_LTE

QOF_COMPARE_EQUAL = _gnucash_core_c.QOF_COMPARE_EQUAL

QOF_COMPARE_GT = _gnucash_core_c.QOF_COMPARE_GT

QOF_COMPARE_GTE = _gnucash_core_c.QOF_COMPARE_GTE

QOF_COMPARE_NEQ = _gnucash_core_c.QOF_COMPARE_NEQ

QOF_COMPARE_CONTAINS = _gnucash_core_c.QOF_COMPARE_CONTAINS

QOF_COMPARE_NCONTAINS = _gnucash_core_c.QOF_COMPARE_NCONTAINS

QOF_STRING_MATCH_NORMAL = _gnucash_core_c.QOF_STRING_MATCH_NORMAL

QOF_STRING_MATCH_CASEINSENSITIVE = _gnucash_core_c.QOF_STRING_MATCH_CASEINSENSITIVE

QOF_DATE_MATCH_NORMAL = _gnucash_core_c.QOF_DATE_MATCH_NORMAL

QOF_DATE_MATCH_DAY = _gnucash_core_c.QOF_DATE_MATCH_DAY

QOF_NUMERIC_MATCH_DEBIT = _gnucash_core_c.QOF_NUMERIC_MATCH_DEBIT

QOF_NUMERIC_MATCH_CREDIT = _gnucash_core_c.QOF_NUMERIC_MATCH_CREDIT

QOF_NUMERIC_MATCH_ANY = _gnucash_core_c.QOF_NUMERIC_MATCH_ANY

QOF_GUID_MATCH_ANY = _gnucash_core_c.QOF_GUID_MATCH_ANY

QOF_GUID_MATCH_NONE = _gnucash_core_c.QOF_GUID_MATCH_NONE

QOF_GUID_MATCH_NULL = _gnucash_core_c.QOF_GUID_MATCH_NULL

QOF_GUID_MATCH_ALL = _gnucash_core_c.QOF_GUID_MATCH_ALL

QOF_GUID_MATCH_LIST_ANY = _gnucash_core_c.QOF_GUID_MATCH_LIST_ANY

QOF_CHAR_MATCH_ANY = _gnucash_core_c.QOF_CHAR_MATCH_ANY

QOF_CHAR_MATCH_NONE = _gnucash_core_c.QOF_CHAR_MATCH_NONE

class _QofQueryPredData(object):
    r"""Proxy of C _QofQueryPredData struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type_name = property(_gnucash_core_c._QofQueryPredData_type_name_get, _gnucash_core_c._QofQueryPredData_type_name_set, doc=r"""type_name : QofType""")
    how = property(_gnucash_core_c._QofQueryPredData_how_get, _gnucash_core_c._QofQueryPredData_how_set, doc=r"""how : QofQueryCompare""")

    def __init__(self):
        r"""__init__(_QofQueryPredData self) -> _QofQueryPredData"""
        _gnucash_core_c._QofQueryPredData_swiginit(self, _gnucash_core_c.new__QofQueryPredData())
    __swig_destroy__ = _gnucash_core_c.delete__QofQueryPredData

# Register _QofQueryPredData in _gnucash_core_c:
_gnucash_core_c._QofQueryPredData_swigregister(_QofQueryPredData)

def qof_query_string_predicate(how, str, options, is_regex):
    r"""qof_query_string_predicate(QofQueryCompare how, gchar const * str, QofStringMatch options, gboolean is_regex) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_string_predicate(how, str, options, is_regex)

def qof_query_date_predicate(how, options, date):
    r"""qof_query_date_predicate(QofQueryCompare how, QofDateMatch options, time64 date) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_date_predicate(how, options, date)

def qof_query_numeric_predicate(how, options, value):
    r"""qof_query_numeric_predicate(QofQueryCompare how, QofNumericMatch options, _gnc_numeric value) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_numeric_predicate(how, options, value)

def qof_query_guid_predicate(options, guids):
    r"""qof_query_guid_predicate(QofGuidMatch options, GList * guids) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_guid_predicate(options, guids)

def qof_query_int32_predicate(how, val):
    r"""qof_query_int32_predicate(QofQueryCompare how, gint32 val) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_int32_predicate(how, val)

def qof_query_int64_predicate(how, val):
    r"""qof_query_int64_predicate(QofQueryCompare how, gint64 val) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_int64_predicate(how, val)

def qof_query_double_predicate(how, val):
    r"""qof_query_double_predicate(QofQueryCompare how, double val) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_double_predicate(how, val)

def qof_query_boolean_predicate(how, val):
    r"""qof_query_boolean_predicate(QofQueryCompare how, gboolean val) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_boolean_predicate(how, val)

def qof_query_char_predicate(options, chars):
    r"""qof_query_char_predicate(QofCharMatch options, gchar const * chars) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_char_predicate(options, chars)

def qof_query_choice_predicate(options, guids):
    r"""qof_query_choice_predicate(QofGuidMatch options, GList * guids) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_choice_predicate(options, guids)

def qof_query_core_predicate_copy(pdata):
    r"""qof_query_core_predicate_copy(_QofQueryPredData pdata) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_core_predicate_copy(pdata)

def qof_query_core_predicate_free(pdata):
    r"""qof_query_core_predicate_free(_QofQueryPredData pdata)"""
    return _gnucash_core_c.qof_query_core_predicate_free(pdata)

def qof_query_date_predicate_get_date(pd):
    r"""qof_query_date_predicate_get_date(_QofQueryPredData pd) -> gboolean"""
    return _gnucash_core_c.qof_query_date_predicate_get_date(pd)

def qof_query_char_predicate_get_char(pd, chars):
    r"""qof_query_char_predicate_get_char(_QofQueryPredData pd, char ** chars) -> gboolean"""
    return _gnucash_core_c.qof_query_char_predicate_get_char(pd, chars)

def qof_query_core_to_string(arg1, object, getter):
    r"""qof_query_core_to_string(QofType arg1, gpointer object, QofParam * getter) -> char *"""
    return _gnucash_core_c.qof_query_core_to_string(arg1, object, getter)

def qof_string_number_compare_func(a, b, options, this_param):
    r"""qof_string_number_compare_func(gpointer a, gpointer b, gint options, QofParam * this_param) -> int"""
    return _gnucash_core_c.qof_string_number_compare_func(a, b, options, this_param)
GUID_DATA_SIZE = _gnucash_core_c.GUID_DATA_SIZE

class GncGUID(object):
    r"""Proxy of C _gncGuid struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    reserved = property(_gnucash_core_c.GncGUID_reserved_get, _gnucash_core_c.GncGUID_reserved_set, doc=r"""reserved : a(16).unsigned char""")

    def __init__(self):
        r"""__init__(GncGUID self) -> GncGUID"""
        _gnucash_core_c.GncGUID_swiginit(self, _gnucash_core_c.new_GncGUID())
    __swig_destroy__ = _gnucash_core_c.delete_GncGUID

# Register GncGUID in _gnucash_core_c:
_gnucash_core_c.GncGUID_swigregister(GncGUID)

def gnc_guid_get_type():
    r"""gnc_guid_get_type() -> GType"""
    return _gnucash_core_c.gnc_guid_get_type()

def gnc_value_get_guid(value):
    r"""gnc_value_get_guid(GValue const * value) -> GncGUID"""
    return _gnucash_core_c.gnc_value_get_guid(value)
GUID_ENCODING_LENGTH = _gnucash_core_c.GUID_ENCODING_LENGTH


def guid_replace(guid):
    r"""guid_replace(GncGUID guid)"""
    return _gnucash_core_c.guid_replace(guid)

def guid_new_return():
    r"""guid_new_return() -> GncGUID"""
    return _gnucash_core_c.guid_new_return()

def guid_null():
    r"""guid_null() -> GncGUID"""
    return _gnucash_core_c.guid_null()

def guid_malloc():
    r"""guid_malloc() -> GncGUID"""
    return _gnucash_core_c.guid_malloc()

def guid_new():
    r"""guid_new() -> GncGUID"""
    return _gnucash_core_c.guid_new()

def guid_free(guid):
    r"""guid_free(GncGUID guid)"""
    return _gnucash_core_c.guid_free(guid)

def guid_copy(guid):
    r"""guid_copy(GncGUID guid) -> GncGUID"""
    return _gnucash_core_c.guid_copy(guid)

def guid_to_string(guid):
    r"""guid_to_string(GncGUID guid) -> gchar *"""
    return _gnucash_core_c.guid_to_string(guid)

def guid_to_string_buff(guid, buff):
    r"""guid_to_string_buff(GncGUID guid, gchar * buff) -> gchar *"""
    return _gnucash_core_c.guid_to_string_buff(guid, buff)

def string_to_guid(string, guid):
    r"""string_to_guid(gchar const * string, GncGUID guid) -> gboolean"""
    return _gnucash_core_c.string_to_guid(string, guid)

def guid_equal(guid_1, guid_2):
    r"""guid_equal(GncGUID guid_1, GncGUID guid_2) -> gboolean"""
    return _gnucash_core_c.guid_equal(guid_1, guid_2)

def guid_compare(g1, g2):
    r"""guid_compare(GncGUID g1, GncGUID g2) -> gint"""
    return _gnucash_core_c.guid_compare(g1, g2)

def guid_hash_to_guint(ptr):
    r"""guid_hash_to_guint(gconstpointer ptr) -> guint"""
    return _gnucash_core_c.guid_hash_to_guint(ptr)

def guid_g_hash_table_equal(guid_a, guid_b):
    r"""guid_g_hash_table_equal(gconstpointer guid_a, gconstpointer guid_b) -> gint"""
    return _gnucash_core_c.guid_g_hash_table_equal(guid_a, guid_b)

def guid_hash_table_new():
    r"""guid_hash_table_new() -> GHashTable *"""
    return _gnucash_core_c.guid_hash_table_new()
class _gnc_numeric(object):
    r"""Proxy of C _gnc_numeric struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    num = property(_gnucash_core_c._gnc_numeric_num_get, _gnucash_core_c._gnc_numeric_num_set, doc=r"""num : gint64""")
    denom = property(_gnucash_core_c._gnc_numeric_denom_get, _gnucash_core_c._gnc_numeric_denom_set, doc=r"""denom : gint64""")

    def __init__(self):
        r"""__init__(_gnc_numeric self) -> _gnc_numeric"""
        _gnucash_core_c._gnc_numeric_swiginit(self, _gnucash_core_c.new__gnc_numeric())
    __swig_destroy__ = _gnucash_core_c.delete__gnc_numeric

# Register _gnc_numeric in _gnucash_core_c:
_gnucash_core_c._gnc_numeric_swigregister(_gnc_numeric)
GNC_NUMERIC_RND_MASK = _gnucash_core_c.GNC_NUMERIC_RND_MASK

GNC_NUMERIC_DENOM_MASK = _gnucash_core_c.GNC_NUMERIC_DENOM_MASK

GNC_NUMERIC_SIGFIGS_MASK = _gnucash_core_c.GNC_NUMERIC_SIGFIGS_MASK

GNC_HOW_RND_FLOOR = _gnucash_core_c.GNC_HOW_RND_FLOOR

GNC_HOW_RND_CEIL = _gnucash_core_c.GNC_HOW_RND_CEIL

GNC_HOW_RND_TRUNC = _gnucash_core_c.GNC_HOW_RND_TRUNC

GNC_HOW_RND_PROMOTE = _gnucash_core_c.GNC_HOW_RND_PROMOTE

GNC_HOW_RND_ROUND_HALF_DOWN = _gnucash_core_c.GNC_HOW_RND_ROUND_HALF_DOWN

GNC_HOW_RND_ROUND_HALF_UP = _gnucash_core_c.GNC_HOW_RND_ROUND_HALF_UP

GNC_HOW_RND_ROUND = _gnucash_core_c.GNC_HOW_RND_ROUND

GNC_HOW_RND_NEVER = _gnucash_core_c.GNC_HOW_RND_NEVER

GNC_HOW_DENOM_EXACT = _gnucash_core_c.GNC_HOW_DENOM_EXACT

GNC_HOW_DENOM_REDUCE = _gnucash_core_c.GNC_HOW_DENOM_REDUCE

GNC_HOW_DENOM_LCD = _gnucash_core_c.GNC_HOW_DENOM_LCD

GNC_HOW_DENOM_FIXED = _gnucash_core_c.GNC_HOW_DENOM_FIXED

GNC_HOW_DENOM_SIGFIG = _gnucash_core_c.GNC_HOW_DENOM_SIGFIG

GNC_ERROR_OK = _gnucash_core_c.GNC_ERROR_OK

GNC_ERROR_ARG = _gnucash_core_c.GNC_ERROR_ARG

GNC_ERROR_OVERFLOW = _gnucash_core_c.GNC_ERROR_OVERFLOW

GNC_ERROR_DENOM_DIFF = _gnucash_core_c.GNC_ERROR_DENOM_DIFF

GNC_ERROR_REMAINDER = _gnucash_core_c.GNC_ERROR_REMAINDER

GNC_DENOM_AUTO = _gnucash_core_c.GNC_DENOM_AUTO


def gnc_numeric_create(num, denom):
    r"""gnc_numeric_create(gint64 num, gint64 denom) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_create(num, denom)

def gnc_numeric_zero():
    r"""gnc_numeric_zero() -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_zero()

def double_to_gnc_numeric(n, denom, how):
    r"""double_to_gnc_numeric(double n, gint64 denom, gint how) -> _gnc_numeric"""
    return _gnucash_core_c.double_to_gnc_numeric(n, denom, how)

def gnc_numeric_from_string(str):
    r"""gnc_numeric_from_string(gchar const * str) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_from_string(str)

def gnc_numeric_error(error_code):
    r"""gnc_numeric_error(GNCNumericErrorCode error_code) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_error(error_code)

def gnc_numeric_errorCode_to_string(error_code):
    r"""gnc_numeric_errorCode_to_string(GNCNumericErrorCode error_code) -> char const *"""
    return _gnucash_core_c.gnc_numeric_errorCode_to_string(error_code)

def gnc_numeric_num(a):
    r"""gnc_numeric_num(_gnc_numeric a) -> gint64"""
    return _gnucash_core_c.gnc_numeric_num(a)

def gnc_numeric_denom(a):
    r"""gnc_numeric_denom(_gnc_numeric a) -> gint64"""
    return _gnucash_core_c.gnc_numeric_denom(a)

def gnc_numeric_to_double(n):
    r"""gnc_numeric_to_double(_gnc_numeric n) -> gdouble"""
    return _gnucash_core_c.gnc_numeric_to_double(n)

def gnc_numeric_to_string(n):
    r"""gnc_numeric_to_string(_gnc_numeric n) -> gchar *"""
    return _gnucash_core_c.gnc_numeric_to_string(n)

def gnc_num_dbg_to_string(n):
    r"""gnc_num_dbg_to_string(_gnc_numeric n) -> gchar *"""
    return _gnucash_core_c.gnc_num_dbg_to_string(n)

def gnc_numeric_check(a):
    r"""gnc_numeric_check(_gnc_numeric a) -> GNCNumericErrorCode"""
    return _gnucash_core_c.gnc_numeric_check(a)

def gnc_numeric_compare(a, b):
    r"""gnc_numeric_compare(_gnc_numeric a, _gnc_numeric b) -> gint"""
    return _gnucash_core_c.gnc_numeric_compare(a, b)

def gnc_numeric_zero_p(a):
    r"""gnc_numeric_zero_p(_gnc_numeric a) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_zero_p(a)

def gnc_numeric_negative_p(a):
    r"""gnc_numeric_negative_p(_gnc_numeric a) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_negative_p(a)

def gnc_numeric_positive_p(a):
    r"""gnc_numeric_positive_p(_gnc_numeric a) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_positive_p(a)

def gnc_numeric_eq(a, b):
    r"""gnc_numeric_eq(_gnc_numeric a, _gnc_numeric b) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_eq(a, b)

def gnc_numeric_equal(a, b):
    r"""gnc_numeric_equal(_gnc_numeric a, _gnc_numeric b) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_equal(a, b)

def gnc_numeric_same(a, b, denom, how):
    r"""gnc_numeric_same(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how) -> gint"""
    return _gnucash_core_c.gnc_numeric_same(a, b, denom, how)

def gnc_numeric_add(a, b, denom, how):
    r"""gnc_numeric_add(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_add(a, b, denom, how)

def gnc_numeric_sub(a, b, denom, how):
    r"""gnc_numeric_sub(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_sub(a, b, denom, how)

def gnc_numeric_mul(a, b, denom, how):
    r"""gnc_numeric_mul(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_mul(a, b, denom, how)

def gnc_numeric_div(x, y, denom, how):
    r"""gnc_numeric_div(_gnc_numeric x, _gnc_numeric y, gint64 denom, gint how) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_div(x, y, denom, how)

def gnc_numeric_neg(a):
    r"""gnc_numeric_neg(_gnc_numeric a) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_neg(a)

def gnc_numeric_abs(a):
    r"""gnc_numeric_abs(_gnc_numeric a) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_abs(a)

def gnc_numeric_add_fixed(a, b):
    r"""gnc_numeric_add_fixed(_gnc_numeric a, _gnc_numeric b) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_add_fixed(a, b)

def gnc_numeric_sub_fixed(a, b):
    r"""gnc_numeric_sub_fixed(_gnc_numeric a, _gnc_numeric b) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_sub_fixed(a, b)

def gnc_numeric_convert(n, denom, how):
    r"""gnc_numeric_convert(_gnc_numeric n, gint64 denom, gint how) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_convert(n, denom, how)

def gnc_numeric_reduce(n):
    r"""gnc_numeric_reduce(_gnc_numeric n) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_reduce(n)

def gnc_numeric_to_decimal(a, max_decimal_places):
    r"""gnc_numeric_to_decimal(_gnc_numeric a, guint8 * max_decimal_places) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_to_decimal(a, max_decimal_places)

def gnc_numeric_invert(num):
    r"""gnc_numeric_invert(_gnc_numeric num) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_invert(num)

def gnc_numeric_get_type():
    r"""gnc_numeric_get_type() -> GType"""
    return _gnucash_core_c.gnc_numeric_get_type()

def gnc_commodity_get_type():
    r"""gnc_commodity_get_type() -> GType"""
    return _gnucash_core_c.gnc_commodity_get_type()

def gnc_commodity_namespace_get_type():
    r"""gnc_commodity_namespace_get_type() -> GType"""
    return _gnucash_core_c.gnc_commodity_namespace_get_type()
GNC_COMMODITY_TABLE = _gnucash_core_c.GNC_COMMODITY_TABLE

GNC_COMMODITY_NS_LEGACY = _gnucash_core_c.GNC_COMMODITY_NS_LEGACY

GNC_COMMODITY_NS_TEMPLATE = _gnucash_core_c.GNC_COMMODITY_NS_TEMPLATE

GNC_COMMODITY_NS_ISO = _gnucash_core_c.GNC_COMMODITY_NS_ISO

GNC_COMMODITY_NS_CURRENCY = _gnucash_core_c.GNC_COMMODITY_NS_CURRENCY

GNC_COMMODITY_NS_NONCURRENCY = _gnucash_core_c.GNC_COMMODITY_NS_NONCURRENCY

GNC_COMMODITY_MAX_FRACTION = _gnucash_core_c.GNC_COMMODITY_MAX_FRACTION

SOURCE_SINGLE = _gnucash_core_c.SOURCE_SINGLE

SOURCE_MULTI = _gnucash_core_c.SOURCE_MULTI

SOURCE_UNKNOWN = _gnucash_core_c.SOURCE_UNKNOWN

SOURCE_MAX = _gnucash_core_c.SOURCE_MAX

SOURCE_CURRENCY = _gnucash_core_c.SOURCE_CURRENCY


def gnc_quote_source_fq_installed():
    r"""gnc_quote_source_fq_installed() -> gboolean"""
    return _gnucash_core_c.gnc_quote_source_fq_installed()

def gnc_quote_source_fq_version():
    r"""gnc_quote_source_fq_version() -> char const *"""
    return _gnucash_core_c.gnc_quote_source_fq_version()

def gnc_quote_source_num_entries(type):
    r"""gnc_quote_source_num_entries(QuoteSourceType type) -> gint"""
    return _gnucash_core_c.gnc_quote_source_num_entries(type)

def gnc_quote_source_add_new(name, supported):
    r"""gnc_quote_source_add_new(char const * name, gboolean supported) -> gnc_quote_source *"""
    return _gnucash_core_c.gnc_quote_source_add_new(name, supported)

def gnc_quote_source_lookup_by_internal(internal_name):
    r"""gnc_quote_source_lookup_by_internal(char const * internal_name) -> gnc_quote_source *"""
    return _gnucash_core_c.gnc_quote_source_lookup_by_internal(internal_name)

def gnc_quote_source_lookup_by_ti(type, index):
    r"""gnc_quote_source_lookup_by_ti(QuoteSourceType type, gint index) -> gnc_quote_source *"""
    return _gnucash_core_c.gnc_quote_source_lookup_by_ti(type, index)

def gnc_quote_source_get_supported(source):
    r"""gnc_quote_source_get_supported(gnc_quote_source const * source) -> gboolean"""
    return _gnucash_core_c.gnc_quote_source_get_supported(source)

def gnc_quote_source_get_type(source):
    r"""gnc_quote_source_get_type(gnc_quote_source const * source) -> QuoteSourceType"""
    return _gnucash_core_c.gnc_quote_source_get_type(source)

def gnc_quote_source_get_index(source):
    r"""gnc_quote_source_get_index(gnc_quote_source const * source) -> gint"""
    return _gnucash_core_c.gnc_quote_source_get_index(source)

def gnc_quote_source_get_user_name(source):
    r"""gnc_quote_source_get_user_name(gnc_quote_source const * source) -> char const *"""
    return _gnucash_core_c.gnc_quote_source_get_user_name(source)

def gnc_quote_source_get_internal_name(source):
    r"""gnc_quote_source_get_internal_name(gnc_quote_source const * source) -> char const *"""
    return _gnucash_core_c.gnc_quote_source_get_internal_name(source)

def gnc_commodity_new(book, fullname, commodity_namespace, mnemonic, cusip, fraction):
    r"""gnc_commodity_new(QofBook * book, char const * fullname, char const * commodity_namespace, char const * mnemonic, char const * cusip, int fraction) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_new(book, fullname, commodity_namespace, mnemonic, cusip, fraction)

def gnc_commodity_destroy(cm):
    r"""gnc_commodity_destroy(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_destroy(cm)

def gnc_commodity_copy(dest, src):
    r"""gnc_commodity_copy(gnc_commodity * dest, gnc_commodity const * src)"""
    return _gnucash_core_c.gnc_commodity_copy(dest, src)

def gnc_commodity_clone(src, dest_book):
    r"""gnc_commodity_clone(gnc_commodity const * src, QofBook * dest_book) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_clone(src, dest_book)

def gnc_commodity_get_auto_quote_control_flag(cm):
    r"""gnc_commodity_get_auto_quote_control_flag(gnc_commodity const * cm) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_get_auto_quote_control_flag(cm)

def gnc_commodity_get_mnemonic(cm):
    r"""gnc_commodity_get_mnemonic(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_mnemonic(cm)

def gnc_commodity_get_namespace(cm):
    r"""gnc_commodity_get_namespace(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_namespace(cm)

def gnc_commodity_get_namespace_ds(cm):
    r"""gnc_commodity_get_namespace_ds(gnc_commodity const * cm) -> gnc_commodity_namespace *"""
    return _gnucash_core_c.gnc_commodity_get_namespace_ds(cm)

def gnc_commodity_get_fullname(cm):
    r"""gnc_commodity_get_fullname(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_fullname(cm)

def gnc_commodity_get_printname(cm):
    r"""gnc_commodity_get_printname(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_printname(cm)

def gnc_commodity_get_cusip(cm):
    r"""gnc_commodity_get_cusip(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_cusip(cm)

def gnc_commodity_get_unique_name(cm):
    r"""gnc_commodity_get_unique_name(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_unique_name(cm)

def gnc_commodity_get_fraction(cm):
    r"""gnc_commodity_get_fraction(gnc_commodity const * cm) -> int"""
    return _gnucash_core_c.gnc_commodity_get_fraction(cm)

def gnc_commodity_get_quote_flag(cm):
    r"""gnc_commodity_get_quote_flag(gnc_commodity const * cm) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_get_quote_flag(cm)

def gnc_commodity_get_quote_source(cm):
    r"""gnc_commodity_get_quote_source(gnc_commodity const * cm) -> gnc_quote_source *"""
    return _gnucash_core_c.gnc_commodity_get_quote_source(cm)

def gnc_commodity_get_default_quote_source(cm):
    r"""gnc_commodity_get_default_quote_source(gnc_commodity const * cm) -> gnc_quote_source *"""
    return _gnucash_core_c.gnc_commodity_get_default_quote_source(cm)

def gnc_commodity_get_quote_tz(cm):
    r"""gnc_commodity_get_quote_tz(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_quote_tz(cm)

def gnc_commodity_get_user_symbol(cm):
    r"""gnc_commodity_get_user_symbol(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_user_symbol(cm)

def gnc_commodity_get_default_symbol(cm):
    r"""gnc_commodity_get_default_symbol(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_default_symbol(cm)

def gnc_commodity_get_nice_symbol(cm):
    r"""gnc_commodity_get_nice_symbol(gnc_commodity const * cm) -> char const *"""
    return _gnucash_core_c.gnc_commodity_get_nice_symbol(cm)

def gnc_commodity_set_auto_quote_control_flag(cm, flag):
    r"""gnc_commodity_set_auto_quote_control_flag(gnc_commodity * cm, gboolean const flag)"""
    return _gnucash_core_c.gnc_commodity_set_auto_quote_control_flag(cm, flag)

def gnc_commodity_set_mnemonic(cm, mnemonic):
    r"""gnc_commodity_set_mnemonic(gnc_commodity * cm, char const * mnemonic)"""
    return _gnucash_core_c.gnc_commodity_set_mnemonic(cm, mnemonic)

def gnc_commodity_set_namespace(cm, new_namespace):
    r"""gnc_commodity_set_namespace(gnc_commodity * cm, char const * new_namespace)"""
    return _gnucash_core_c.gnc_commodity_set_namespace(cm, new_namespace)

def gnc_commodity_set_fullname(cm, fullname):
    r"""gnc_commodity_set_fullname(gnc_commodity * cm, char const * fullname)"""
    return _gnucash_core_c.gnc_commodity_set_fullname(cm, fullname)

def gnc_commodity_set_cusip(cm, cusip):
    r"""gnc_commodity_set_cusip(gnc_commodity * cm, char const * cusip)"""
    return _gnucash_core_c.gnc_commodity_set_cusip(cm, cusip)

def gnc_commodity_set_fraction(cm, smallest_fraction):
    r"""gnc_commodity_set_fraction(gnc_commodity * cm, int smallest_fraction)"""
    return _gnucash_core_c.gnc_commodity_set_fraction(cm, smallest_fraction)

def gnc_commodity_user_set_quote_flag(cm, flag):
    r"""gnc_commodity_user_set_quote_flag(gnc_commodity * cm, gboolean const flag)"""
    return _gnucash_core_c.gnc_commodity_user_set_quote_flag(cm, flag)

def gnc_commodity_set_quote_flag(cm, flag):
    r"""gnc_commodity_set_quote_flag(gnc_commodity * cm, gboolean const flag)"""
    return _gnucash_core_c.gnc_commodity_set_quote_flag(cm, flag)

def gnc_commodity_set_quote_source(cm, src):
    r"""gnc_commodity_set_quote_source(gnc_commodity * cm, gnc_quote_source * src)"""
    return _gnucash_core_c.gnc_commodity_set_quote_source(cm, src)

def gnc_commodity_set_quote_tz(cm, tz):
    r"""gnc_commodity_set_quote_tz(gnc_commodity * cm, char const * tz)"""
    return _gnucash_core_c.gnc_commodity_set_quote_tz(cm, tz)

def gnc_commodity_set_user_symbol(cm, user_symbol):
    r"""gnc_commodity_set_user_symbol(gnc_commodity * cm, char const * user_symbol)"""
    return _gnucash_core_c.gnc_commodity_set_user_symbol(cm, user_symbol)

def gnc_commodity_increment_usage_count(cm):
    r"""gnc_commodity_increment_usage_count(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_increment_usage_count(cm)

def gnc_commodity_decrement_usage_count(cm):
    r"""gnc_commodity_decrement_usage_count(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_decrement_usage_count(cm)

def gnc_commodity_equiv(a, b):
    r"""gnc_commodity_equiv(gnc_commodity const * a, gnc_commodity const * b) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_equiv(a, b)

def gnc_commodity_equal(a, b):
    r"""gnc_commodity_equal(gnc_commodity const * a, gnc_commodity const * b) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_equal(a, b)

def gnc_commodity_compare(a, b):
    r"""gnc_commodity_compare(gnc_commodity const * a, gnc_commodity const * b) -> int"""
    return _gnucash_core_c.gnc_commodity_compare(a, b)

def gnc_commodity_compare_void(a, b):
    r"""gnc_commodity_compare_void(void const * a, void const * b) -> int"""
    return _gnucash_core_c.gnc_commodity_compare_void(a, b)

def gnc_commodity_namespace_is_iso(commodity_namespace):
    r"""gnc_commodity_namespace_is_iso(char const * commodity_namespace) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_namespace_is_iso(commodity_namespace)

def gnc_commodity_is_iso(cm):
    r"""gnc_commodity_is_iso(gnc_commodity const * cm) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_is_iso(cm)

def gnc_commodity_is_currency(cm):
    r"""gnc_commodity_is_currency(gnc_commodity const * cm) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_is_currency(cm)

def gnc_commodity_table_get_table(book):
    r"""gnc_commodity_table_get_table(QofBook * book) -> gnc_commodity_table *"""
    return _gnucash_core_c.gnc_commodity_table_get_table(book)

def gnc_commodity_table_lookup(table, commodity_namespace, mnemonic):
    r"""gnc_commodity_table_lookup(gnc_commodity_table const * table, char const * commodity_namespace, char const * mnemonic) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_table_lookup(table, commodity_namespace, mnemonic)

def gnc_commodity_table_lookup_unique(table, unique_name):
    r"""gnc_commodity_table_lookup_unique(gnc_commodity_table const * table, char const * unique_name) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_table_lookup_unique(table, unique_name)

def gnc_commodity_table_find_full(t, commodity_namespace, fullname):
    r"""gnc_commodity_table_find_full(gnc_commodity_table const * t, char const * commodity_namespace, char const * fullname) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_table_find_full(t, commodity_namespace, fullname)

def gnc_commodity_find_commodity_by_guid(guid, book):
    r"""gnc_commodity_find_commodity_by_guid(GncGUID guid, QofBook * book) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_find_commodity_by_guid(guid, book)

def gnc_commodity_table_insert(table, comm):
    r"""gnc_commodity_table_insert(gnc_commodity_table * table, gnc_commodity * comm) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_table_insert(table, comm)

def gnc_commodity_table_remove(table, comm):
    r"""gnc_commodity_table_remove(gnc_commodity_table * table, gnc_commodity * comm)"""
    return _gnucash_core_c.gnc_commodity_table_remove(table, comm)

def gnc_commodity_table_add_default_data(table, book):
    r"""gnc_commodity_table_add_default_data(gnc_commodity_table * table, QofBook * book) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_table_add_default_data(table, book)

def gnc_commodity_namespace_get_name(ns):
    r"""gnc_commodity_namespace_get_name(gnc_commodity_namespace const * ns) -> char const *"""
    return _gnucash_core_c.gnc_commodity_namespace_get_name(ns)

def gnc_commodity_namespace_get_gui_name(ns):
    r"""gnc_commodity_namespace_get_gui_name(gnc_commodity_namespace const * ns) -> char const *"""
    return _gnucash_core_c.gnc_commodity_namespace_get_gui_name(ns)

def gnc_commodity_namespace_get_commodity_list(ns):
    r"""gnc_commodity_namespace_get_commodity_list(gnc_commodity_namespace const * ns) -> GList *"""
    return _gnucash_core_c.gnc_commodity_namespace_get_commodity_list(ns)

def gnc_commodity_table_has_namespace(table, commodity_namespace):
    r"""gnc_commodity_table_has_namespace(gnc_commodity_table const * table, char const * commodity_namespace) -> int"""
    return _gnucash_core_c.gnc_commodity_table_has_namespace(table, commodity_namespace)

def gnc_commodity_table_get_namespaces(t):
    r"""gnc_commodity_table_get_namespaces(gnc_commodity_table const * t) -> GList *"""
    return _gnucash_core_c.gnc_commodity_table_get_namespaces(t)

def gnc_commodity_table_get_namespaces_list(t):
    r"""gnc_commodity_table_get_namespaces_list(gnc_commodity_table const * t) -> GList *"""
    return _gnucash_core_c.gnc_commodity_table_get_namespaces_list(t)

def gnc_commodity_table_add_namespace(table, commodity_namespace, book):
    r"""gnc_commodity_table_add_namespace(gnc_commodity_table * table, char const * commodity_namespace, QofBook * book) -> gnc_commodity_namespace *"""
    return _gnucash_core_c.gnc_commodity_table_add_namespace(table, commodity_namespace, book)

def gnc_commodity_table_find_namespace(table, commodity_namespace):
    r"""gnc_commodity_table_find_namespace(gnc_commodity_table const * table, char const * commodity_namespace) -> gnc_commodity_namespace *"""
    return _gnucash_core_c.gnc_commodity_table_find_namespace(table, commodity_namespace)

def gnc_commodity_table_delete_namespace(table, commodity_namespace):
    r"""gnc_commodity_table_delete_namespace(gnc_commodity_table * table, char const * commodity_namespace)"""
    return _gnucash_core_c.gnc_commodity_table_delete_namespace(table, commodity_namespace)

def gnc_commodity_table_get_size(tbl):
    r"""gnc_commodity_table_get_size(gnc_commodity_table const * tbl) -> guint"""
    return _gnucash_core_c.gnc_commodity_table_get_size(tbl)

def gnc_commodity_table_get_commodities(table, commodity_namespace):
    r"""gnc_commodity_table_get_commodities(gnc_commodity_table const * table, char const * commodity_namespace) -> CommodityList *"""
    return _gnucash_core_c.gnc_commodity_table_get_commodities(table, commodity_namespace)

def gnc_commodity_table_get_quotable_commodities(table):
    r"""gnc_commodity_table_get_quotable_commodities(gnc_commodity_table const * table) -> CommodityList *"""
    return _gnucash_core_c.gnc_commodity_table_get_quotable_commodities(table)

def gnc_commodity_table_foreach_commodity(table, f, user_data):
    r"""gnc_commodity_table_foreach_commodity(gnc_commodity_table const * table, gboolean (*)(gnc_commodity *,gpointer) f, gpointer user_data) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_table_foreach_commodity(table, f, user_data)

def gnc_commodity_table_new():
    r"""gnc_commodity_table_new() -> gnc_commodity_table *"""
    return _gnucash_core_c.gnc_commodity_table_new()

def gnc_commodity_table_destroy(table):
    r"""gnc_commodity_table_destroy(gnc_commodity_table * table)"""
    return _gnucash_core_c.gnc_commodity_table_destroy(table)

def gnc_commodity_obtain_twin(findlike, book):
    r"""gnc_commodity_obtain_twin(gnc_commodity const * findlike, QofBook * book) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_commodity_obtain_twin(findlike, book)

def gnc_commodity_table_register():
    r"""gnc_commodity_table_register() -> gboolean"""
    return _gnucash_core_c.gnc_commodity_table_register()

def gnc_commodity_begin_edit(cm):
    r"""gnc_commodity_begin_edit(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_begin_edit(cm)

def gnc_commodity_commit_edit(cm):
    r"""gnc_commodity_commit_edit(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_commit_edit(cm)
class _gnc_monetary(object):
    r"""Proxy of C _gnc_monetary struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    commodity = property(_gnucash_core_c._gnc_monetary_commodity_get, _gnucash_core_c._gnc_monetary_commodity_set, doc=r"""commodity : p.gnc_commodity""")
    value = property(_gnucash_core_c._gnc_monetary_value_get, _gnucash_core_c._gnc_monetary_value_set, doc=r"""value : gnc_numeric""")

    def __init__(self):
        r"""__init__(_gnc_monetary self) -> _gnc_monetary"""
        _gnucash_core_c._gnc_monetary_swiginit(self, _gnucash_core_c.new__gnc_monetary())
    __swig_destroy__ = _gnucash_core_c.delete__gnc_monetary

# Register _gnc_monetary in _gnucash_core_c:
_gnucash_core_c._gnc_monetary_swigregister(_gnc_monetary)

def gnc_monetary_create(commod, val):
    r"""gnc_monetary_create(gnc_commodity * commod, _gnc_numeric val) -> _gnc_monetary"""
    return _gnucash_core_c.gnc_monetary_create(commod, val)

def gnc_monetary_commodity(a):
    r"""gnc_monetary_commodity(_gnc_monetary a) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_monetary_commodity(a)

def gnc_monetary_value(a):
    r"""gnc_monetary_value(_gnc_monetary a) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_monetary_value(a)

def gnc_monetary_list_add_monetary(list, mon):
    r"""gnc_monetary_list_add_monetary(MonetaryList * list, _gnc_monetary mon) -> MonetaryList *"""
    return _gnucash_core_c.gnc_monetary_list_add_monetary(list, mon)

def gnc_monetary_list_add_value(list, commod, value):
    r"""gnc_monetary_list_add_value(MonetaryList * list, gnc_commodity * commod, _gnc_numeric value) -> MonetaryList *"""
    return _gnucash_core_c.gnc_monetary_list_add_value(list, commod, value)

def gnc_monetary_list_delete_zeros(list):
    r"""gnc_monetary_list_delete_zeros(MonetaryList * list) -> MonetaryList *"""
    return _gnucash_core_c.gnc_monetary_list_delete_zeros(list)

def gnc_monetary_list_free(list):
    r"""gnc_monetary_list_free(MonetaryList * list)"""
    return _gnucash_core_c.gnc_monetary_list_free(list)

def gncEntryGetGUID(x):
    r"""gncEntryGetGUID(GncEntry * x) -> GncGUID"""
    return _gnucash_core_c.gncEntryGetGUID(x)
GNC_ID_OWNER = _gnucash_core_c.GNC_ID_OWNER

GNC_OWNER_NONE = _gnucash_core_c.GNC_OWNER_NONE

GNC_OWNER_UNDEFINED = _gnucash_core_c.GNC_OWNER_UNDEFINED

GNC_OWNER_CUSTOMER = _gnucash_core_c.GNC_OWNER_CUSTOMER

GNC_OWNER_JOB = _gnucash_core_c.GNC_OWNER_JOB

GNC_OWNER_VENDOR = _gnucash_core_c.GNC_OWNER_VENDOR

GNC_OWNER_EMPLOYEE = _gnucash_core_c.GNC_OWNER_EMPLOYEE


def qofOwnerGetType(owner):
    r"""qofOwnerGetType(GncOwner const * owner) -> QofIdTypeConst"""
    return _gnucash_core_c.qofOwnerGetType(owner)

def gncOwnerGetTypeString(owner):
    r"""gncOwnerGetTypeString(GncOwner const * owner) -> char const *"""
    return _gnucash_core_c.gncOwnerGetTypeString(owner)

def qofOwnerGetOwner(owner):
    r"""qofOwnerGetOwner(GncOwner const * owner) -> QofInstance *"""
    return _gnucash_core_c.qofOwnerGetOwner(owner)

def qofOwnerSetEntity(owner, ent):
    r"""qofOwnerSetEntity(GncOwner * owner, QofInstance * ent)"""
    return _gnucash_core_c.qofOwnerSetEntity(owner, ent)

def GNC_IS_OWNER(ent):
    r"""GNC_IS_OWNER(QofInstance * ent) -> gboolean"""
    return _gnucash_core_c.GNC_IS_OWNER(ent)

def gncOwnerTypeToQofIdType(t):
    r"""gncOwnerTypeToQofIdType(GncOwnerType t) -> QofIdTypeConst"""
    return _gnucash_core_c.gncOwnerTypeToQofIdType(t)

def gncOwnerRegister():
    r"""gncOwnerRegister() -> gboolean"""
    return _gnucash_core_c.gncOwnerRegister()

def gncOwnerInitUndefined(owner, obj):
    r"""gncOwnerInitUndefined(GncOwner * owner, gpointer obj)"""
    return _gnucash_core_c.gncOwnerInitUndefined(owner, obj)

def gncOwnerInitCustomer(owner, customer):
    r"""gncOwnerInitCustomer(GncOwner * owner, GncCustomer * customer)"""
    return _gnucash_core_c.gncOwnerInitCustomer(owner, customer)

def gncOwnerInitJob(owner, job):
    r"""gncOwnerInitJob(GncOwner * owner, GncJob * job)"""
    return _gnucash_core_c.gncOwnerInitJob(owner, job)

def gncOwnerInitVendor(owner, vendor):
    r"""gncOwnerInitVendor(GncOwner * owner, GncVendor * vendor)"""
    return _gnucash_core_c.gncOwnerInitVendor(owner, vendor)

def gncOwnerInitEmployee(owner, employee):
    r"""gncOwnerInitEmployee(GncOwner * owner, GncEmployee * employee)"""
    return _gnucash_core_c.gncOwnerInitEmployee(owner, employee)

def gncOwnerGetType(owner):
    r"""gncOwnerGetType(GncOwner const * owner) -> GncOwnerType"""
    return _gnucash_core_c.gncOwnerGetType(owner)

def gncOwnerIsValid(owner):
    r"""gncOwnerIsValid(GncOwner const * owner) -> gboolean"""
    return _gnucash_core_c.gncOwnerIsValid(owner)

def gncOwnerGetUndefined(owner):
    r"""gncOwnerGetUndefined(GncOwner const * owner) -> gpointer"""
    return _gnucash_core_c.gncOwnerGetUndefined(owner)

def gncOwnerGetCustomer(owner):
    r"""gncOwnerGetCustomer(GncOwner const * owner) -> GncCustomer *"""
    return _gnucash_core_c.gncOwnerGetCustomer(owner)

def gncOwnerGetJob(owner):
    r"""gncOwnerGetJob(GncOwner const * owner) -> GncJob *"""
    return _gnucash_core_c.gncOwnerGetJob(owner)

def gncOwnerGetVendor(owner):
    r"""gncOwnerGetVendor(GncOwner const * owner) -> GncVendor *"""
    return _gnucash_core_c.gncOwnerGetVendor(owner)

def gncOwnerGetEmployee(owner):
    r"""gncOwnerGetEmployee(GncOwner const * owner) -> GncEmployee *"""
    return _gnucash_core_c.gncOwnerGetEmployee(owner)

def gncOwnerGetID(owner):
    r"""gncOwnerGetID(GncOwner const * owner) -> char const *"""
    return _gnucash_core_c.gncOwnerGetID(owner)

def gncOwnerGetName(owner):
    r"""gncOwnerGetName(GncOwner const * owner) -> char const *"""
    return _gnucash_core_c.gncOwnerGetName(owner)

def gncOwnerGetAddr(owner):
    r"""gncOwnerGetAddr(GncOwner const * owner) -> GncAddress *"""
    return _gnucash_core_c.gncOwnerGetAddr(owner)

def gncOwnerGetActive(owner):
    r"""gncOwnerGetActive(GncOwner const * owner) -> gboolean"""
    return _gnucash_core_c.gncOwnerGetActive(owner)

def gncOwnerGetCurrency(owner):
    r"""gncOwnerGetCurrency(GncOwner const * owner) -> gnc_commodity *"""
    return _gnucash_core_c.gncOwnerGetCurrency(owner)

def gncOwnerSetActive(owner, active):
    r"""gncOwnerSetActive(GncOwner const * owner, gboolean active)"""
    return _gnucash_core_c.gncOwnerSetActive(owner, active)

def gncOwnerCopy(src, dest):
    r"""gncOwnerCopy(GncOwner const * src, GncOwner * dest)"""
    return _gnucash_core_c.gncOwnerCopy(src, dest)

def gncOwnerEqual(a, b):
    r"""gncOwnerEqual(GncOwner const * a, GncOwner const * b) -> gboolean"""
    return _gnucash_core_c.gncOwnerEqual(a, b)

def gncOwnerGCompareFunc(a, b):
    r"""gncOwnerGCompareFunc(GncOwner const * a, GncOwner const * b) -> int"""
    return _gnucash_core_c.gncOwnerGCompareFunc(a, b)

def gncOwnerCompare(a, b):
    r"""gncOwnerCompare(GncOwner const * a, GncOwner const * b) -> int"""
    return _gnucash_core_c.gncOwnerCompare(a, b)

def gncOwnerGetGUID(owner):
    r"""gncOwnerGetGUID(GncOwner const * owner) -> GncGUID"""
    return _gnucash_core_c.gncOwnerGetGUID(owner)

def gncOwnerRetGUID(owner):
    r"""gncOwnerRetGUID(GncOwner * owner) -> GncGUID"""
    return _gnucash_core_c.gncOwnerRetGUID(owner)

def gncOwnerGetEndOwner(owner):
    r"""gncOwnerGetEndOwner(GncOwner const * owner) -> GncOwner const *"""
    return _gnucash_core_c.gncOwnerGetEndOwner(owner)

def gncOwnerGetEndGUID(owner):
    r"""gncOwnerGetEndGUID(GncOwner const * owner) -> GncGUID"""
    return _gnucash_core_c.gncOwnerGetEndGUID(owner)

def gncOwnerAttachToLot(owner, lot):
    r"""gncOwnerAttachToLot(GncOwner const * owner, GNCLot * lot)"""
    return _gnucash_core_c.gncOwnerAttachToLot(owner, lot)

def gncOwnerLotMatchOwnerFunc(lot, user_data):
    r"""gncOwnerLotMatchOwnerFunc(GNCLot * lot, gpointer user_data) -> gboolean"""
    return _gnucash_core_c.gncOwnerLotMatchOwnerFunc(lot, user_data)

def gncOwnerLotsSortFunc(lotA, lotB):
    r"""gncOwnerLotsSortFunc(GNCLot * lotA, GNCLot * lotB) -> gint"""
    return _gnucash_core_c.gncOwnerLotsSortFunc(lotA, lotB)

def gncOwnerGetOwnerFromLot(lot, owner):
    r"""gncOwnerGetOwnerFromLot(GNCLot * lot, GncOwner * owner) -> gboolean"""
    return _gnucash_core_c.gncOwnerGetOwnerFromLot(lot, owner)

def gncOwnerGetOwnerFromTxn(txn, owner):
    r"""gncOwnerGetOwnerFromTxn(Transaction * txn, GncOwner * owner) -> gboolean"""
    return _gnucash_core_c.gncOwnerGetOwnerFromTxn(txn, owner)

def gncOwnerGetOwnerFromTypeGuid(book, owner, type, guid):
    r"""gncOwnerGetOwnerFromTypeGuid(QofBook * book, GncOwner * owner, QofIdType type, GncGUID guid) -> gboolean"""
    return _gnucash_core_c.gncOwnerGetOwnerFromTypeGuid(book, owner, type, guid)

def gncOwnerCreatePaymentLotSecs(owner, preset_txn, posted_acc, xfer_acc, amount, exch, date, memo, num):
    r"""gncOwnerCreatePaymentLotSecs(GncOwner const * owner, Transaction ** preset_txn, Account * posted_acc, Account * xfer_acc, _gnc_numeric amount, _gnc_numeric exch, time64 date, char const * memo, char const * num) -> GNCLot *"""
    return _gnucash_core_c.gncOwnerCreatePaymentLotSecs(owner, preset_txn, posted_acc, xfer_acc, amount, exch, date, memo, num)

def gncOwnerAutoApplyPaymentsWithLots(owner, lots):
    r"""gncOwnerAutoApplyPaymentsWithLots(GncOwner const * owner, GList * lots)"""
    return _gnucash_core_c.gncOwnerAutoApplyPaymentsWithLots(owner, lots)

def gncOwnerApplyPaymentSecs(owner, preset_txn, lots, posted_acc, xfer_acc, amount, exch, date, memo, num, auto_pay):
    r"""gncOwnerApplyPaymentSecs(GncOwner const * owner, Transaction ** preset_txn, GList * lots, Account * posted_acc, Account * xfer_acc, _gnc_numeric amount, _gnc_numeric exch, time64 date, char const * memo, char const * num, gboolean auto_pay)"""
    return _gnucash_core_c.gncOwnerApplyPaymentSecs(owner, preset_txn, lots, posted_acc, xfer_acc, amount, exch, date, memo, num, auto_pay)

def gncOwnerFindOffsettingSplit(lot, target_amount):
    r"""gncOwnerFindOffsettingSplit(GNCLot * lot, _gnc_numeric target_amount) -> Split *"""
    return _gnucash_core_c.gncOwnerFindOffsettingSplit(lot, target_amount)

def gncOwnerReduceSplitTo(split, target_amount):
    r"""gncOwnerReduceSplitTo(Split * split, _gnc_numeric target_amount) -> gboolean"""
    return _gnucash_core_c.gncOwnerReduceSplitTo(split, target_amount)

def gncOwnerSetLotLinkMemo(ll_txn):
    r"""gncOwnerSetLotLinkMemo(Transaction * ll_txn)"""
    return _gnucash_core_c.gncOwnerSetLotLinkMemo(ll_txn)

def gncOwnerGetAccountTypesList(owner):
    r"""gncOwnerGetAccountTypesList(GncOwner const * owner) -> GList *"""
    return _gnucash_core_c.gncOwnerGetAccountTypesList(owner)

def gncOwnerGetCommoditiesList(owner):
    r"""gncOwnerGetCommoditiesList(GncOwner const * owner) -> GList *"""
    return _gnucash_core_c.gncOwnerGetCommoditiesList(owner)

def gncOwnerGetBalanceInCurrency(owner, report_currency):
    r"""gncOwnerGetBalanceInCurrency(GncOwner const * owner, gnc_commodity const * report_currency) -> _gnc_numeric"""
    return _gnucash_core_c.gncOwnerGetBalanceInCurrency(owner, report_currency)
OWNER_TYPE = _gnucash_core_c.OWNER_TYPE

OWNER_TYPE_STRING = _gnucash_core_c.OWNER_TYPE_STRING

OWNER_CUSTOMER = _gnucash_core_c.OWNER_CUSTOMER

OWNER_JOB = _gnucash_core_c.OWNER_JOB

OWNER_VENDOR = _gnucash_core_c.OWNER_VENDOR

OWNER_EMPLOYEE = _gnucash_core_c.OWNER_EMPLOYEE

OWNER_PARENT = _gnucash_core_c.OWNER_PARENT

OWNER_PARENTG = _gnucash_core_c.OWNER_PARENTG

OWNER_NAME = _gnucash_core_c.OWNER_NAME

OWNER_FROM_LOT = _gnucash_core_c.OWNER_FROM_LOT


def gncOwnerNew():
    r"""gncOwnerNew() -> GncOwner *"""
    return _gnucash_core_c.gncOwnerNew()

def gncOwnerFree(owner):
    r"""gncOwnerFree(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerFree(owner)

def gncOwnerBeginEdit(owner):
    r"""gncOwnerBeginEdit(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerBeginEdit(owner)

def gncOwnerCommitEdit(owner):
    r"""gncOwnerCommitEdit(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerCommitEdit(owner)

def gncOwnerDestroy(owner):
    r"""gncOwnerDestroy(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerDestroy(owner)
GNC_ID_CUSTOMER = _gnucash_core_c.GNC_ID_CUSTOMER


def gnc_customer_get_type():
    r"""gnc_customer_get_type() -> GType"""
    return _gnucash_core_c.gnc_customer_get_type()

def gncCustomerCreate(book):
    r"""gncCustomerCreate(QofBook * book) -> GncCustomer *"""
    return _gnucash_core_c.gncCustomerCreate(book)

def gncCustomerDestroy(customer):
    r"""gncCustomerDestroy(GncCustomer * customer)"""
    return _gnucash_core_c.gncCustomerDestroy(customer)

def gncCustomerBeginEdit(customer):
    r"""gncCustomerBeginEdit(GncCustomer * customer)"""
    return _gnucash_core_c.gncCustomerBeginEdit(customer)

def gncCustomerCommitEdit(customer):
    r"""gncCustomerCommitEdit(GncCustomer * customer)"""
    return _gnucash_core_c.gncCustomerCommitEdit(customer)

def gncCustomerSetID(customer, id):
    r"""gncCustomerSetID(GncCustomer * customer, char const * id)"""
    return _gnucash_core_c.gncCustomerSetID(customer, id)

def gncCustomerSetName(customer, name):
    r"""gncCustomerSetName(GncCustomer * customer, char const * name)"""
    return _gnucash_core_c.gncCustomerSetName(customer, name)

def gncCustomerSetNotes(customer, notes):
    r"""gncCustomerSetNotes(GncCustomer * customer, char const * notes)"""
    return _gnucash_core_c.gncCustomerSetNotes(customer, notes)

def gncCustomerSetTerms(customer, term):
    r"""gncCustomerSetTerms(GncCustomer * customer, GncBillTerm * term)"""
    return _gnucash_core_c.gncCustomerSetTerms(customer, term)

def gncCustomerSetTaxIncluded(customer, taxincl):
    r"""gncCustomerSetTaxIncluded(GncCustomer * customer, GncTaxIncluded taxincl)"""
    return _gnucash_core_c.gncCustomerSetTaxIncluded(customer, taxincl)

def gncCustomerSetActive(customer, active):
    r"""gncCustomerSetActive(GncCustomer * customer, gboolean active)"""
    return _gnucash_core_c.gncCustomerSetActive(customer, active)

def gncCustomerSetDiscount(customer, discount):
    r"""gncCustomerSetDiscount(GncCustomer * customer, _gnc_numeric discount)"""
    return _gnucash_core_c.gncCustomerSetDiscount(customer, discount)

def gncCustomerSetCredit(customer, credit):
    r"""gncCustomerSetCredit(GncCustomer * customer, _gnc_numeric credit)"""
    return _gnucash_core_c.gncCustomerSetCredit(customer, credit)

def gncCustomerSetCurrency(customer, currency):
    r"""gncCustomerSetCurrency(GncCustomer * customer, gnc_commodity * currency)"""
    return _gnucash_core_c.gncCustomerSetCurrency(customer, currency)

def gncCustomerSetTaxTableOverride(customer, override):
    r"""gncCustomerSetTaxTableOverride(GncCustomer * customer, gboolean override)"""
    return _gnucash_core_c.gncCustomerSetTaxTableOverride(customer, override)

def gncCustomerSetTaxTable(customer, table):
    r"""gncCustomerSetTaxTable(GncCustomer * customer, GncTaxTable * table)"""
    return _gnucash_core_c.gncCustomerSetTaxTable(customer, table)

def gncCustomerAddJob(customer, job):
    r"""gncCustomerAddJob(GncCustomer * customer, GncJob * job)"""
    return _gnucash_core_c.gncCustomerAddJob(customer, job)

def gncCustomerRemoveJob(customer, job):
    r"""gncCustomerRemoveJob(GncCustomer * customer, GncJob * job)"""
    return _gnucash_core_c.gncCustomerRemoveJob(customer, job)

def gncCustomerLookup(book, guid):
    r"""gncCustomerLookup(QofBook const * book, GncGUID guid) -> GncCustomer *"""
    return _gnucash_core_c.gncCustomerLookup(book, guid)

def gncCustomerGetID(customer):
    r"""gncCustomerGetID(GncCustomer const * customer) -> char const *"""
    return _gnucash_core_c.gncCustomerGetID(customer)

def gncCustomerGetName(customer):
    r"""gncCustomerGetName(GncCustomer const * customer) -> char const *"""
    return _gnucash_core_c.gncCustomerGetName(customer)

def gncCustomerGetAddr(customer):
    r"""gncCustomerGetAddr(GncCustomer const * customer) -> GncAddress *"""
    return _gnucash_core_c.gncCustomerGetAddr(customer)

def gncCustomerGetShipAddr(customer):
    r"""gncCustomerGetShipAddr(GncCustomer const * customer) -> GncAddress *"""
    return _gnucash_core_c.gncCustomerGetShipAddr(customer)

def gncCustomerGetNotes(customer):
    r"""gncCustomerGetNotes(GncCustomer const * customer) -> char const *"""
    return _gnucash_core_c.gncCustomerGetNotes(customer)

def gncCustomerGetTerms(customer):
    r"""gncCustomerGetTerms(GncCustomer const * customer) -> GncBillTerm *"""
    return _gnucash_core_c.gncCustomerGetTerms(customer)

def gncCustomerGetTaxIncluded(customer):
    r"""gncCustomerGetTaxIncluded(GncCustomer const * customer) -> GncTaxIncluded"""
    return _gnucash_core_c.gncCustomerGetTaxIncluded(customer)

def gncCustomerGetActive(customer):
    r"""gncCustomerGetActive(GncCustomer const * customer) -> gboolean"""
    return _gnucash_core_c.gncCustomerGetActive(customer)

def gncCustomerGetDiscount(customer):
    r"""gncCustomerGetDiscount(GncCustomer const * customer) -> _gnc_numeric"""
    return _gnucash_core_c.gncCustomerGetDiscount(customer)

def gncCustomerGetCredit(customer):
    r"""gncCustomerGetCredit(GncCustomer const * customer) -> _gnc_numeric"""
    return _gnucash_core_c.gncCustomerGetCredit(customer)

def gncCustomerGetCurrency(customer):
    r"""gncCustomerGetCurrency(GncCustomer const * customer) -> gnc_commodity *"""
    return _gnucash_core_c.gncCustomerGetCurrency(customer)

def gncCustomerGetTaxTableOverride(customer):
    r"""gncCustomerGetTaxTableOverride(GncCustomer const * customer) -> gboolean"""
    return _gnucash_core_c.gncCustomerGetTaxTableOverride(customer)

def gncCustomerGetTaxTable(customer):
    r"""gncCustomerGetTaxTable(GncCustomer const * customer) -> GncTaxTable *"""
    return _gnucash_core_c.gncCustomerGetTaxTable(customer)

def gncCustomerCompare(a, b):
    r"""gncCustomerCompare(GncCustomer const * a, GncCustomer const * b) -> int"""
    return _gnucash_core_c.gncCustomerCompare(a, b)
CUSTOMER_ID = _gnucash_core_c.CUSTOMER_ID

CUSTOMER_NAME = _gnucash_core_c.CUSTOMER_NAME

CUSTOMER_ADDR = _gnucash_core_c.CUSTOMER_ADDR

CUSTOMER_SHIPADDR = _gnucash_core_c.CUSTOMER_SHIPADDR

CUSTOMER_NOTES = _gnucash_core_c.CUSTOMER_NOTES

CUSTOMER_DISCOUNT = _gnucash_core_c.CUSTOMER_DISCOUNT

CUSTOMER_CREDIT = _gnucash_core_c.CUSTOMER_CREDIT

CUSTOMER_TT_OVER = _gnucash_core_c.CUSTOMER_TT_OVER

CUSTOMER_TAX_INC = _gnucash_core_c.CUSTOMER_TAX_INC

CUSTOMER_TERMS = _gnucash_core_c.CUSTOMER_TERMS

CUSTOMER_ACTIVE = _gnucash_core_c.CUSTOMER_ACTIVE

CUSTOMER_SLOTS = _gnucash_core_c.CUSTOMER_SLOTS


def gncCustomerEqual(a, b):
    r"""gncCustomerEqual(GncCustomer const * a, GncCustomer const * b) -> gboolean"""
    return _gnucash_core_c.gncCustomerEqual(a, b)

def gncCustomerGetJoblist(customer, show_all):
    r"""gncCustomerGetJoblist(GncCustomer const * customer, gboolean show_all) -> GList *"""
    return _gnucash_core_c.gncCustomerGetJoblist(customer, show_all)

def gncCustomerIsDirty(customer):
    r"""gncCustomerIsDirty(GncCustomer * customer) -> gboolean"""
    return _gnucash_core_c.gncCustomerIsDirty(customer)

def gncCustomerRegister():
    r"""gncCustomerRegister() -> gboolean"""
    return _gnucash_core_c.gncCustomerRegister()

def gncCustomerNextID(book):
    r"""gncCustomerNextID(QofBook * book) -> gchar *"""
    return _gnucash_core_c.gncCustomerNextID(book)

def gncCustomerGetCachedBalance(cust):
    r"""gncCustomerGetCachedBalance(GncCustomer * cust) -> _gnc_numeric"""
    return _gnucash_core_c.gncCustomerGetCachedBalance(cust)

def gncCustomerSetCachedBalance(cust, new_bal):
    r"""gncCustomerSetCachedBalance(GncCustomer * cust, _gnc_numeric new_bal)"""
    return _gnucash_core_c.gncCustomerSetCachedBalance(cust, new_bal)
GNC_ID_EMPLOYEE = _gnucash_core_c.GNC_ID_EMPLOYEE


def gnc_employee_get_type():
    r"""gnc_employee_get_type() -> GType"""
    return _gnucash_core_c.gnc_employee_get_type()

def gncEmployeeCreate(book):
    r"""gncEmployeeCreate(QofBook * book) -> GncEmployee *"""
    return _gnucash_core_c.gncEmployeeCreate(book)

def gncEmployeeDestroy(employee):
    r"""gncEmployeeDestroy(GncEmployee * employee)"""
    return _gnucash_core_c.gncEmployeeDestroy(employee)

def gncEmployeeBeginEdit(employee):
    r"""gncEmployeeBeginEdit(GncEmployee * employee)"""
    return _gnucash_core_c.gncEmployeeBeginEdit(employee)

def gncEmployeeCommitEdit(employee):
    r"""gncEmployeeCommitEdit(GncEmployee * employee)"""
    return _gnucash_core_c.gncEmployeeCommitEdit(employee)

def gncEmployeeCompare(a, b):
    r"""gncEmployeeCompare(GncEmployee const * a, GncEmployee const * b) -> int"""
    return _gnucash_core_c.gncEmployeeCompare(a, b)

def gncEmployeeSetID(employee, id):
    r"""gncEmployeeSetID(GncEmployee * employee, char const * id)"""
    return _gnucash_core_c.gncEmployeeSetID(employee, id)

def gncEmployeeSetUsername(employee, username):
    r"""gncEmployeeSetUsername(GncEmployee * employee, char const * username)"""
    return _gnucash_core_c.gncEmployeeSetUsername(employee, username)

def gncEmployeeSetName(employee, name):
    r"""gncEmployeeSetName(GncEmployee * employee, char const * name)"""
    return _gnucash_core_c.gncEmployeeSetName(employee, name)

def gncEmployeeSetLanguage(employee, language):
    r"""gncEmployeeSetLanguage(GncEmployee * employee, char const * language)"""
    return _gnucash_core_c.gncEmployeeSetLanguage(employee, language)

def gncEmployeeSetAcl(employee, acl):
    r"""gncEmployeeSetAcl(GncEmployee * employee, char const * acl)"""
    return _gnucash_core_c.gncEmployeeSetAcl(employee, acl)

def gncEmployeeSetWorkday(employee, workday):
    r"""gncEmployeeSetWorkday(GncEmployee * employee, _gnc_numeric workday)"""
    return _gnucash_core_c.gncEmployeeSetWorkday(employee, workday)

def gncEmployeeSetRate(employee, rate):
    r"""gncEmployeeSetRate(GncEmployee * employee, _gnc_numeric rate)"""
    return _gnucash_core_c.gncEmployeeSetRate(employee, rate)

def gncEmployeeSetCurrency(employee, currency):
    r"""gncEmployeeSetCurrency(GncEmployee * employee, gnc_commodity * currency)"""
    return _gnucash_core_c.gncEmployeeSetCurrency(employee, currency)

def gncEmployeeSetActive(employee, active):
    r"""gncEmployeeSetActive(GncEmployee * employee, gboolean active)"""
    return _gnucash_core_c.gncEmployeeSetActive(employee, active)

def gncEmployeeSetCCard(employee, ccard_acc):
    r"""gncEmployeeSetCCard(GncEmployee * employee, Account * ccard_acc)"""
    return _gnucash_core_c.gncEmployeeSetCCard(employee, ccard_acc)

def qofEmployeeSetAddr(employee, addr_ent):
    r"""qofEmployeeSetAddr(GncEmployee * employee, QofInstance * addr_ent)"""
    return _gnucash_core_c.qofEmployeeSetAddr(employee, addr_ent)

def gncEmployeeGetBook(employee):
    r"""gncEmployeeGetBook(GncEmployee * employee) -> QofBook *"""
    return _gnucash_core_c.gncEmployeeGetBook(employee)

def gncEmployeeGetID(employee):
    r"""gncEmployeeGetID(GncEmployee const * employee) -> char const *"""
    return _gnucash_core_c.gncEmployeeGetID(employee)

def gncEmployeeGetUsername(employee):
    r"""gncEmployeeGetUsername(GncEmployee const * employee) -> char const *"""
    return _gnucash_core_c.gncEmployeeGetUsername(employee)

def gncEmployeeGetName(employee):
    r"""gncEmployeeGetName(GncEmployee const * employee) -> char const *"""
    return _gnucash_core_c.gncEmployeeGetName(employee)

def gncEmployeeGetAddr(employee):
    r"""gncEmployeeGetAddr(GncEmployee const * employee) -> GncAddress *"""
    return _gnucash_core_c.gncEmployeeGetAddr(employee)

def gncEmployeeGetLanguage(employee):
    r"""gncEmployeeGetLanguage(GncEmployee const * employee) -> char const *"""
    return _gnucash_core_c.gncEmployeeGetLanguage(employee)

def gncEmployeeGetAcl(employee):
    r"""gncEmployeeGetAcl(GncEmployee const * employee) -> char const *"""
    return _gnucash_core_c.gncEmployeeGetAcl(employee)

def gncEmployeeGetWorkday(employee):
    r"""gncEmployeeGetWorkday(GncEmployee const * employee) -> _gnc_numeric"""
    return _gnucash_core_c.gncEmployeeGetWorkday(employee)

def gncEmployeeGetRate(employee):
    r"""gncEmployeeGetRate(GncEmployee const * employee) -> _gnc_numeric"""
    return _gnucash_core_c.gncEmployeeGetRate(employee)

def gncEmployeeGetCurrency(employee):
    r"""gncEmployeeGetCurrency(GncEmployee const * employee) -> gnc_commodity *"""
    return _gnucash_core_c.gncEmployeeGetCurrency(employee)

def gncEmployeeGetActive(employee):
    r"""gncEmployeeGetActive(GncEmployee const * employee) -> gboolean"""
    return _gnucash_core_c.gncEmployeeGetActive(employee)

def gncEmployeeGetCCard(employee):
    r"""gncEmployeeGetCCard(GncEmployee const * employee) -> Account *"""
    return _gnucash_core_c.gncEmployeeGetCCard(employee)

def gncEmployeeLookup(book, guid):
    r"""gncEmployeeLookup(QofBook const * book, GncGUID guid) -> GncEmployee *"""
    return _gnucash_core_c.gncEmployeeLookup(book, guid)
EMPLOYEE_ID = _gnucash_core_c.EMPLOYEE_ID

EMPLOYEE_USERNAME = _gnucash_core_c.EMPLOYEE_USERNAME

EMPLOYEE_NAME = _gnucash_core_c.EMPLOYEE_NAME

EMPLOYEE_ADDR = _gnucash_core_c.EMPLOYEE_ADDR

EMPLOYEE_LANGUAGE = _gnucash_core_c.EMPLOYEE_LANGUAGE

EMPLOYEE_ACL = _gnucash_core_c.EMPLOYEE_ACL

EMPLOYEE_WORKDAY = _gnucash_core_c.EMPLOYEE_WORKDAY

EMPLOYEE_RATE = _gnucash_core_c.EMPLOYEE_RATE

EMPLOYEE_CC = _gnucash_core_c.EMPLOYEE_CC


def gncEmployeeEqual(e1, e2):
    r"""gncEmployeeEqual(GncEmployee const * e1, GncEmployee const * e2) -> gboolean"""
    return _gnucash_core_c.gncEmployeeEqual(e1, e2)

def gncEmployeeIsDirty(employee):
    r"""gncEmployeeIsDirty(GncEmployee const * employee) -> gboolean"""
    return _gnucash_core_c.gncEmployeeIsDirty(employee)
GNC_ID_VENDOR = _gnucash_core_c.GNC_ID_VENDOR


def gnc_vendor_get_type():
    r"""gnc_vendor_get_type() -> GType"""
    return _gnucash_core_c.gnc_vendor_get_type()

def gncVendorCreate(book):
    r"""gncVendorCreate(QofBook * book) -> GncVendor *"""
    return _gnucash_core_c.gncVendorCreate(book)

def gncVendorDestroy(vendor):
    r"""gncVendorDestroy(GncVendor * vendor)"""
    return _gnucash_core_c.gncVendorDestroy(vendor)

def gncVendorSetID(vendor, id):
    r"""gncVendorSetID(GncVendor * vendor, char const * id)"""
    return _gnucash_core_c.gncVendorSetID(vendor, id)

def gncVendorSetName(vendor, name):
    r"""gncVendorSetName(GncVendor * vendor, char const * name)"""
    return _gnucash_core_c.gncVendorSetName(vendor, name)

def gncVendorSetNotes(vendor, notes):
    r"""gncVendorSetNotes(GncVendor * vendor, char const * notes)"""
    return _gnucash_core_c.gncVendorSetNotes(vendor, notes)

def gncVendorSetTerms(vendor, terms):
    r"""gncVendorSetTerms(GncVendor * vendor, GncBillTerm * terms)"""
    return _gnucash_core_c.gncVendorSetTerms(vendor, terms)

def gncVendorSetTaxIncluded(vendor, taxincl):
    r"""gncVendorSetTaxIncluded(GncVendor * vendor, GncTaxIncluded taxincl)"""
    return _gnucash_core_c.gncVendorSetTaxIncluded(vendor, taxincl)

def gncVendorSetCurrency(vendor, currency):
    r"""gncVendorSetCurrency(GncVendor * vendor, gnc_commodity * currency)"""
    return _gnucash_core_c.gncVendorSetCurrency(vendor, currency)

def gncVendorSetActive(vendor, active):
    r"""gncVendorSetActive(GncVendor * vendor, gboolean active)"""
    return _gnucash_core_c.gncVendorSetActive(vendor, active)

def gncVendorSetTaxTableOverride(vendor, override):
    r"""gncVendorSetTaxTableOverride(GncVendor * vendor, gboolean override)"""
    return _gnucash_core_c.gncVendorSetTaxTableOverride(vendor, override)

def gncVendorSetTaxTable(vendor, table):
    r"""gncVendorSetTaxTable(GncVendor * vendor, GncTaxTable * table)"""
    return _gnucash_core_c.gncVendorSetTaxTable(vendor, table)

def gncVendorAddJob(vendor, job):
    r"""gncVendorAddJob(GncVendor * vendor, GncJob * job)"""
    return _gnucash_core_c.gncVendorAddJob(vendor, job)

def gncVendorRemoveJob(vendor, job):
    r"""gncVendorRemoveJob(GncVendor * vendor, GncJob * job)"""
    return _gnucash_core_c.gncVendorRemoveJob(vendor, job)

def gncVendorBeginEdit(vendor):
    r"""gncVendorBeginEdit(GncVendor * vendor)"""
    return _gnucash_core_c.gncVendorBeginEdit(vendor)

def gncVendorCommitEdit(vendor):
    r"""gncVendorCommitEdit(GncVendor * vendor)"""
    return _gnucash_core_c.gncVendorCommitEdit(vendor)

def gncVendorGetID(vendor):
    r"""gncVendorGetID(GncVendor const * vendor) -> char const *"""
    return _gnucash_core_c.gncVendorGetID(vendor)

def gncVendorGetName(vendor):
    r"""gncVendorGetName(GncVendor const * vendor) -> char const *"""
    return _gnucash_core_c.gncVendorGetName(vendor)

def gncVendorGetAddr(vendor):
    r"""gncVendorGetAddr(GncVendor const * vendor) -> GncAddress *"""
    return _gnucash_core_c.gncVendorGetAddr(vendor)

def gncVendorGetNotes(vendor):
    r"""gncVendorGetNotes(GncVendor const * vendor) -> char const *"""
    return _gnucash_core_c.gncVendorGetNotes(vendor)

def gncVendorGetTerms(vendor):
    r"""gncVendorGetTerms(GncVendor const * vendor) -> GncBillTerm *"""
    return _gnucash_core_c.gncVendorGetTerms(vendor)

def gncVendorGetTaxIncluded(vendor):
    r"""gncVendorGetTaxIncluded(GncVendor const * vendor) -> GncTaxIncluded"""
    return _gnucash_core_c.gncVendorGetTaxIncluded(vendor)

def gncVendorGetCurrency(vendor):
    r"""gncVendorGetCurrency(GncVendor const * vendor) -> gnc_commodity *"""
    return _gnucash_core_c.gncVendorGetCurrency(vendor)

def gncVendorGetActive(vendor):
    r"""gncVendorGetActive(GncVendor const * vendor) -> gboolean"""
    return _gnucash_core_c.gncVendorGetActive(vendor)

def gncVendorGetTaxTableOverride(vendor):
    r"""gncVendorGetTaxTableOverride(GncVendor const * vendor) -> gboolean"""
    return _gnucash_core_c.gncVendorGetTaxTableOverride(vendor)

def gncVendorGetTaxTable(vendor):
    r"""gncVendorGetTaxTable(GncVendor const * vendor) -> GncTaxTable *"""
    return _gnucash_core_c.gncVendorGetTaxTable(vendor)

def gncVendorCompare(a, b):
    r"""gncVendorCompare(GncVendor const * a, GncVendor const * b) -> int"""
    return _gnucash_core_c.gncVendorCompare(a, b)

def gncVendorLookup(book, guid):
    r"""gncVendorLookup(QofBook const * book, GncGUID guid) -> GncVendor *"""
    return _gnucash_core_c.gncVendorLookup(book, guid)
VENDOR_ID = _gnucash_core_c.VENDOR_ID

VENDOR_NAME = _gnucash_core_c.VENDOR_NAME

VENDOR_ADDR = _gnucash_core_c.VENDOR_ADDR

VENDOR_NOTES = _gnucash_core_c.VENDOR_NOTES

VENDOR_TERMS = _gnucash_core_c.VENDOR_TERMS

VENDOR_TAX_INC = _gnucash_core_c.VENDOR_TAX_INC

VENDOR_ACTIVE = _gnucash_core_c.VENDOR_ACTIVE

VENDOR_TAX_OVERRIDE = _gnucash_core_c.VENDOR_TAX_OVERRIDE

VENDOR_TAX_TABLE = _gnucash_core_c.VENDOR_TAX_TABLE


def gncVendorEqual(a, b):
    r"""gncVendorEqual(GncVendor const * a, GncVendor const * b) -> gboolean"""
    return _gnucash_core_c.gncVendorEqual(a, b)

def gncVendorIsDirty(vendor):
    r"""gncVendorIsDirty(GncVendor const * vendor) -> gboolean"""
    return _gnucash_core_c.gncVendorIsDirty(vendor)

def gncVendorRegister():
    r"""gncVendorRegister() -> gboolean"""
    return _gnucash_core_c.gncVendorRegister()

def gncVendorNextID(book):
    r"""gncVendorNextID(QofBook * book) -> gchar *"""
    return _gnucash_core_c.gncVendorNextID(book)

def gncVendorGetCachedBalance(vend):
    r"""gncVendorGetCachedBalance(GncVendor * vend) -> _gnc_numeric"""
    return _gnucash_core_c.gncVendorGetCachedBalance(vend)

def gncVendorSetCachedBalance(vend, new_bal):
    r"""gncVendorSetCachedBalance(GncVendor * vend, _gnc_numeric new_bal)"""
    return _gnucash_core_c.gncVendorSetCachedBalance(vend, new_bal)
GNC_ADDRESS_MODULE_NAME = _gnucash_core_c.GNC_ADDRESS_MODULE_NAME

GNC_ID_ADDRESS = _gnucash_core_c.GNC_ID_ADDRESS


def gnc_address_get_type():
    r"""gnc_address_get_type() -> GType"""
    return _gnucash_core_c.gnc_address_get_type()

def gncAddressCreate(book, parent):
    r"""gncAddressCreate(QofBook * book, QofInstance * parent) -> GncAddress *"""
    return _gnucash_core_c.gncAddressCreate(book, parent)

def gncAddressDestroy(addr):
    r"""gncAddressDestroy(GncAddress * addr)"""
    return _gnucash_core_c.gncAddressDestroy(addr)

def gncAddressBeginEdit(addr):
    r"""gncAddressBeginEdit(GncAddress * addr)"""
    return _gnucash_core_c.gncAddressBeginEdit(addr)

def gncAddressCommitEdit(addr):
    r"""gncAddressCommitEdit(GncAddress * addr)"""
    return _gnucash_core_c.gncAddressCommitEdit(addr)

def gncAddressSetName(addr, name):
    r"""gncAddressSetName(GncAddress * addr, char const * name)"""
    return _gnucash_core_c.gncAddressSetName(addr, name)

def gncAddressSetAddr1(addr, addr1):
    r"""gncAddressSetAddr1(GncAddress * addr, char const * addr1)"""
    return _gnucash_core_c.gncAddressSetAddr1(addr, addr1)

def gncAddressSetAddr2(addr, addr2):
    r"""gncAddressSetAddr2(GncAddress * addr, char const * addr2)"""
    return _gnucash_core_c.gncAddressSetAddr2(addr, addr2)

def gncAddressSetAddr3(addr, addr3):
    r"""gncAddressSetAddr3(GncAddress * addr, char const * addr3)"""
    return _gnucash_core_c.gncAddressSetAddr3(addr, addr3)

def gncAddressSetAddr4(addr, addr4):
    r"""gncAddressSetAddr4(GncAddress * addr, char const * addr4)"""
    return _gnucash_core_c.gncAddressSetAddr4(addr, addr4)

def gncAddressSetPhone(addr, phone):
    r"""gncAddressSetPhone(GncAddress * addr, char const * phone)"""
    return _gnucash_core_c.gncAddressSetPhone(addr, phone)

def gncAddressSetFax(addr, fax):
    r"""gncAddressSetFax(GncAddress * addr, char const * fax)"""
    return _gnucash_core_c.gncAddressSetFax(addr, fax)

def gncAddressSetEmail(addr, email):
    r"""gncAddressSetEmail(GncAddress * addr, char const * email)"""
    return _gnucash_core_c.gncAddressSetEmail(addr, email)

def gncAddressClearDirty(address):
    r"""gncAddressClearDirty(GncAddress * address)"""
    return _gnucash_core_c.gncAddressClearDirty(address)

def gncAddressGetName(addr):
    r"""gncAddressGetName(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetName(addr)

def gncAddressGetAddr1(addr):
    r"""gncAddressGetAddr1(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr1(addr)

def gncAddressGetAddr2(addr):
    r"""gncAddressGetAddr2(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr2(addr)

def gncAddressGetAddr3(addr):
    r"""gncAddressGetAddr3(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr3(addr)

def gncAddressGetAddr4(addr):
    r"""gncAddressGetAddr4(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr4(addr)

def gncAddressGetPhone(addr):
    r"""gncAddressGetPhone(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetPhone(addr)

def gncAddressGetFax(addr):
    r"""gncAddressGetFax(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetFax(addr)

def gncAddressGetEmail(addr):
    r"""gncAddressGetEmail(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetEmail(addr)

def gncAddressIsDirty(addr):
    r"""gncAddressIsDirty(GncAddress const * addr) -> gboolean"""
    return _gnucash_core_c.gncAddressIsDirty(addr)

def gncAddressCompare(a, b):
    r"""gncAddressCompare(GncAddress const * a, GncAddress const * b) -> int"""
    return _gnucash_core_c.gncAddressCompare(a, b)

def gncAddressEqual(a, b):
    r"""gncAddressEqual(GncAddress const * a, GncAddress const * b) -> gboolean"""
    return _gnucash_core_c.gncAddressEqual(a, b)
ADDRESS_NAME = _gnucash_core_c.ADDRESS_NAME

ADDRESS_ONE = _gnucash_core_c.ADDRESS_ONE

ADDRESS_TWO = _gnucash_core_c.ADDRESS_TWO

ADDRESS_THREE = _gnucash_core_c.ADDRESS_THREE

ADDRESS_FOUR = _gnucash_core_c.ADDRESS_FOUR

ADDRESS_PHONE = _gnucash_core_c.ADDRESS_PHONE

ADDRESS_FAX = _gnucash_core_c.ADDRESS_FAX

ADDRESS_EMAIL = _gnucash_core_c.ADDRESS_EMAIL

ADDRESS_OWNER = _gnucash_core_c.ADDRESS_OWNER

GNC_ID_BILLTERM = _gnucash_core_c.GNC_ID_BILLTERM


def gnc_billterm_get_type():
    r"""gnc_billterm_get_type() -> GType"""
    return _gnucash_core_c.gnc_billterm_get_type()
GNC_BILLTERM_NAME = _gnucash_core_c.GNC_BILLTERM_NAME

GNC_BILLTERM_DESC = _gnucash_core_c.GNC_BILLTERM_DESC

GNC_BILLTERM_DUEDAYS = _gnucash_core_c.GNC_BILLTERM_DUEDAYS

GNC_BILLTERM_DISCDAYS = _gnucash_core_c.GNC_BILLTERM_DISCDAYS

GNC_BILLTERM_CUTOFF = _gnucash_core_c.GNC_BILLTERM_CUTOFF

GNC_BILLTERM_TYPE = _gnucash_core_c.GNC_BILLTERM_TYPE

GNC_BILLTERM_DISCOUNT = _gnucash_core_c.GNC_BILLTERM_DISCOUNT

GNC_BILLTERM_REFCOUNT = _gnucash_core_c.GNC_BILLTERM_REFCOUNT

GNC_TERM_TYPE_DAYS = _gnucash_core_c.GNC_TERM_TYPE_DAYS

GNC_TERM_TYPE_PROXIMO = _gnucash_core_c.GNC_TERM_TYPE_PROXIMO


def gncBillTermCreate(book):
    r"""gncBillTermCreate(QofBook * book) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermCreate(book)

def gncBillTermDestroy(term):
    r"""gncBillTermDestroy(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermDestroy(term)

def gncBillTermIncRef(term):
    r"""gncBillTermIncRef(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermIncRef(term)

def gncBillTermDecRef(term):
    r"""gncBillTermDecRef(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermDecRef(term)

def gncBillTermChanged(term):
    r"""gncBillTermChanged(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermChanged(term)

def gncBillTermBeginEdit(term):
    r"""gncBillTermBeginEdit(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermBeginEdit(term)

def gncBillTermCommitEdit(term):
    r"""gncBillTermCommitEdit(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermCommitEdit(term)

def gncBillTermSetName(term, name):
    r"""gncBillTermSetName(GncBillTerm * term, char const * name)"""
    return _gnucash_core_c.gncBillTermSetName(term, name)

def gncBillTermSetDescription(term, name):
    r"""gncBillTermSetDescription(GncBillTerm * term, char const * name)"""
    return _gnucash_core_c.gncBillTermSetDescription(term, name)

def gncBillTermSetType(term, type):
    r"""gncBillTermSetType(GncBillTerm * term, GncBillTermType type)"""
    return _gnucash_core_c.gncBillTermSetType(term, type)

def gncBillTermSetDueDays(term, days):
    r"""gncBillTermSetDueDays(GncBillTerm * term, gint days)"""
    return _gnucash_core_c.gncBillTermSetDueDays(term, days)

def gncBillTermSetDiscountDays(term, days):
    r"""gncBillTermSetDiscountDays(GncBillTerm * term, gint days)"""
    return _gnucash_core_c.gncBillTermSetDiscountDays(term, days)

def gncBillTermSetDiscount(term, discount):
    r"""gncBillTermSetDiscount(GncBillTerm * term, _gnc_numeric discount)"""
    return _gnucash_core_c.gncBillTermSetDiscount(term, discount)

def gncBillTermSetCutoff(term, cutoff):
    r"""gncBillTermSetCutoff(GncBillTerm * term, gint cutoff)"""
    return _gnucash_core_c.gncBillTermSetCutoff(term, cutoff)

def gncBillTermLookup(book, guid):
    r"""gncBillTermLookup(QofBook const * book, GncGUID guid) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermLookup(book, guid)

def gncBillTermLookupByName(book, name):
    r"""gncBillTermLookupByName(QofBook * book, char const * name) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermLookupByName(book, name)

def gncBillTermGetTerms(book):
    r"""gncBillTermGetTerms(QofBook * book) -> GList *"""
    return _gnucash_core_c.gncBillTermGetTerms(book)

def gncBillTermGetName(term):
    r"""gncBillTermGetName(GncBillTerm const * term) -> char const *"""
    return _gnucash_core_c.gncBillTermGetName(term)

def gncBillTermGetDescription(term):
    r"""gncBillTermGetDescription(GncBillTerm const * term) -> char const *"""
    return _gnucash_core_c.gncBillTermGetDescription(term)

def gncBillTermGetType(term):
    r"""gncBillTermGetType(GncBillTerm const * term) -> GncBillTermType"""
    return _gnucash_core_c.gncBillTermGetType(term)

def gncBillTermGetDueDays(term):
    r"""gncBillTermGetDueDays(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetDueDays(term)

def gncBillTermGetDiscountDays(term):
    r"""gncBillTermGetDiscountDays(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetDiscountDays(term)

def gncBillTermGetDiscount(term):
    r"""gncBillTermGetDiscount(GncBillTerm const * term) -> _gnc_numeric"""
    return _gnucash_core_c.gncBillTermGetDiscount(term)

def gncBillTermGetCutoff(term):
    r"""gncBillTermGetCutoff(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetCutoff(term)

def gncBillTermIsDirty(term):
    r"""gncBillTermIsDirty(GncBillTerm const * term) -> gboolean"""
    return _gnucash_core_c.gncBillTermIsDirty(term)

def gncBillTermGetParent(term):
    r"""gncBillTermGetParent(GncBillTerm const * term) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermGetParent(term)

def gncBillTermReturnChild(term, make_new):
    r"""gncBillTermReturnChild(GncBillTerm * term, gboolean make_new) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermReturnChild(term, make_new)

def gncBillTermGetRefcount(term):
    r"""gncBillTermGetRefcount(GncBillTerm const * term) -> gint64"""
    return _gnucash_core_c.gncBillTermGetRefcount(term)

def gncBillTermCompare(a, b):
    r"""gncBillTermCompare(GncBillTerm const * a, GncBillTerm const * b) -> int"""
    return _gnucash_core_c.gncBillTermCompare(a, b)

def gncBillTermEqual(a, b):
    r"""gncBillTermEqual(GncBillTerm const * a, GncBillTerm const * b) -> gboolean"""
    return _gnucash_core_c.gncBillTermEqual(a, b)

def gncBillTermIsFamily(a, b):
    r"""gncBillTermIsFamily(GncBillTerm const * a, GncBillTerm const * b) -> gboolean"""
    return _gnucash_core_c.gncBillTermIsFamily(a, b)

def gncBillTermComputeDueDate(term, post_date):
    r"""gncBillTermComputeDueDate(GncBillTerm const * term, time64 post_date) -> time64"""
    return _gnucash_core_c.gncBillTermComputeDueDate(term, post_date)
GNC_ID_INVOICE = _gnucash_core_c.GNC_ID_INVOICE

GNC_INVOICE_UNDEFINED = _gnucash_core_c.GNC_INVOICE_UNDEFINED

GNC_INVOICE_CUST_INVOICE = _gnucash_core_c.GNC_INVOICE_CUST_INVOICE

GNC_INVOICE_VEND_INVOICE = _gnucash_core_c.GNC_INVOICE_VEND_INVOICE

GNC_INVOICE_EMPL_INVOICE = _gnucash_core_c.GNC_INVOICE_EMPL_INVOICE

GNC_INVOICE_CUST_CREDIT_NOTE = _gnucash_core_c.GNC_INVOICE_CUST_CREDIT_NOTE

GNC_INVOICE_VEND_CREDIT_NOTE = _gnucash_core_c.GNC_INVOICE_VEND_CREDIT_NOTE

GNC_INVOICE_EMPL_CREDIT_NOTE = _gnucash_core_c.GNC_INVOICE_EMPL_CREDIT_NOTE

GNC_INVOICE_NUM_TYPES = _gnucash_core_c.GNC_INVOICE_NUM_TYPES


def gnc_invoice_get_type():
    r"""gnc_invoice_get_type() -> GType"""
    return _gnucash_core_c.gnc_invoice_get_type()

def gncInvoiceCreate(book):
    r"""gncInvoiceCreate(QofBook * book) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceCreate(book)

def gncInvoiceDestroy(invoice):
    r"""gncInvoiceDestroy(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceDestroy(invoice)

def gncInvoiceCopy(other_invoice):
    r"""gncInvoiceCopy(GncInvoice const * other_invoice) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceCopy(other_invoice)

def gncInvoiceSetID(invoice, id):
    r"""gncInvoiceSetID(GncInvoice * invoice, char const * id)"""
    return _gnucash_core_c.gncInvoiceSetID(invoice, id)

def gncInvoiceSetOwner(invoice, owner):
    r"""gncInvoiceSetOwner(GncInvoice * invoice, GncOwner * owner)"""
    return _gnucash_core_c.gncInvoiceSetOwner(invoice, owner)

def gncInvoiceSetDateOpenedGDate(invoice, date):
    r"""gncInvoiceSetDateOpenedGDate(GncInvoice * invoice, GDate const * date)"""
    return _gnucash_core_c.gncInvoiceSetDateOpenedGDate(invoice, date)

def gncInvoiceSetDateOpened(invoice, date):
    r"""gncInvoiceSetDateOpened(GncInvoice * invoice, time64 date)"""
    return _gnucash_core_c.gncInvoiceSetDateOpened(invoice, date)

def gncInvoiceSetDatePosted(invoice, date):
    r"""gncInvoiceSetDatePosted(GncInvoice * invoice, time64 date)"""
    return _gnucash_core_c.gncInvoiceSetDatePosted(invoice, date)

def gncInvoiceSetTerms(invoice, terms):
    r"""gncInvoiceSetTerms(GncInvoice * invoice, GncBillTerm * terms)"""
    return _gnucash_core_c.gncInvoiceSetTerms(invoice, terms)

def gncInvoiceSetBillingID(invoice, billing_id):
    r"""gncInvoiceSetBillingID(GncInvoice * invoice, char const * billing_id)"""
    return _gnucash_core_c.gncInvoiceSetBillingID(invoice, billing_id)

def gncInvoiceSetNotes(invoice, notes):
    r"""gncInvoiceSetNotes(GncInvoice * invoice, char const * notes)"""
    return _gnucash_core_c.gncInvoiceSetNotes(invoice, notes)

def gncInvoiceSetDocLink(invoice, doclink):
    r"""gncInvoiceSetDocLink(GncInvoice * invoice, char const * doclink)"""
    return _gnucash_core_c.gncInvoiceSetDocLink(invoice, doclink)

def gncInvoiceSetCurrency(invoice, currency):
    r"""gncInvoiceSetCurrency(GncInvoice * invoice, gnc_commodity * currency)"""
    return _gnucash_core_c.gncInvoiceSetCurrency(invoice, currency)

def gncInvoiceSetActive(invoice, active):
    r"""gncInvoiceSetActive(GncInvoice * invoice, gboolean active)"""
    return _gnucash_core_c.gncInvoiceSetActive(invoice, active)

def gncInvoiceSetIsCreditNote(invoice, credit_note):
    r"""gncInvoiceSetIsCreditNote(GncInvoice * invoice, gboolean credit_note)"""
    return _gnucash_core_c.gncInvoiceSetIsCreditNote(invoice, credit_note)

def gncInvoiceSetBillTo(invoice, billto):
    r"""gncInvoiceSetBillTo(GncInvoice * invoice, GncOwner * billto)"""
    return _gnucash_core_c.gncInvoiceSetBillTo(invoice, billto)

def gncInvoiceSetToChargeAmount(invoice, amount):
    r"""gncInvoiceSetToChargeAmount(GncInvoice * invoice, _gnc_numeric amount)"""
    return _gnucash_core_c.gncInvoiceSetToChargeAmount(invoice, amount)

def gncInvoiceAddEntry(invoice, entry):
    r"""gncInvoiceAddEntry(GncInvoice * invoice, GncEntry * entry)"""
    return _gnucash_core_c.gncInvoiceAddEntry(invoice, entry)

def gncInvoiceRemoveEntry(invoice, entry):
    r"""gncInvoiceRemoveEntry(GncInvoice * invoice, GncEntry * entry)"""
    return _gnucash_core_c.gncInvoiceRemoveEntry(invoice, entry)

def gncInvoiceAddPrice(invoice, price):
    r"""gncInvoiceAddPrice(GncInvoice * invoice, GNCPrice * price)"""
    return _gnucash_core_c.gncInvoiceAddPrice(invoice, price)

def gncBillAddEntry(bill, entry):
    r"""gncBillAddEntry(GncInvoice * bill, GncEntry * entry)"""
    return _gnucash_core_c.gncBillAddEntry(bill, entry)

def gncBillRemoveEntry(bill, entry):
    r"""gncBillRemoveEntry(GncInvoice * bill, GncEntry * entry)"""
    return _gnucash_core_c.gncBillRemoveEntry(bill, entry)

def gncInvoiceSortEntries(invoice):
    r"""gncInvoiceSortEntries(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceSortEntries(invoice)

def gncInvoiceRemoveEntries(invoice):
    r"""gncInvoiceRemoveEntries(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceRemoveEntries(invoice)

def gncInvoiceGetID(invoice):
    r"""gncInvoiceGetID(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetID(invoice)

def gncInvoiceGetOwner(invoice):
    r"""gncInvoiceGetOwner(GncInvoice const * invoice) -> GncOwner const *"""
    return _gnucash_core_c.gncInvoiceGetOwner(invoice)

def gncInvoiceGetDateOpened(invoice):
    r"""gncInvoiceGetDateOpened(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDateOpened(invoice)

def gncInvoiceGetDatePosted(invoice):
    r"""gncInvoiceGetDatePosted(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDatePosted(invoice)

def gncInvoiceGetDateDue(invoice):
    r"""gncInvoiceGetDateDue(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDateDue(invoice)

def gncInvoiceGetTerms(invoice):
    r"""gncInvoiceGetTerms(GncInvoice const * invoice) -> GncBillTerm *"""
    return _gnucash_core_c.gncInvoiceGetTerms(invoice)

def gncInvoiceGetBillingID(invoice):
    r"""gncInvoiceGetBillingID(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetBillingID(invoice)

def gncInvoiceGetNotes(invoice):
    r"""gncInvoiceGetNotes(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetNotes(invoice)

def gncInvoiceGetDocLink(invoice):
    r"""gncInvoiceGetDocLink(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetDocLink(invoice)

def gncInvoiceGetOwnerType(invoice):
    r"""gncInvoiceGetOwnerType(GncInvoice const * invoice) -> GncOwnerType"""
    return _gnucash_core_c.gncInvoiceGetOwnerType(invoice)

def gncInvoiceGetTypeListForOwnerType(type):
    r"""gncInvoiceGetTypeListForOwnerType(GncOwnerType const type) -> GList *"""
    return _gnucash_core_c.gncInvoiceGetTypeListForOwnerType(type)

def gncInvoiceGetType(invoice):
    r"""gncInvoiceGetType(GncInvoice const * invoice) -> GncInvoiceType"""
    return _gnucash_core_c.gncInvoiceGetType(invoice)

def gncInvoiceGetTypeString(invoice):
    r"""gncInvoiceGetTypeString(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetTypeString(invoice)

def gncInvoiceGetCurrency(invoice):
    r"""gncInvoiceGetCurrency(GncInvoice const * invoice) -> gnc_commodity *"""
    return _gnucash_core_c.gncInvoiceGetCurrency(invoice)

def gncInvoiceGetBillTo(invoice):
    r"""gncInvoiceGetBillTo(GncInvoice * invoice) -> GncOwner *"""
    return _gnucash_core_c.gncInvoiceGetBillTo(invoice)

def gncInvoiceGetToChargeAmount(invoice):
    r"""gncInvoiceGetToChargeAmount(GncInvoice const * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetToChargeAmount(invoice)

def gncInvoiceGetActive(invoice):
    r"""gncInvoiceGetActive(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceGetActive(invoice)

def gncInvoiceGetIsCreditNote(invoice):
    r"""gncInvoiceGetIsCreditNote(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceGetIsCreditNote(invoice)

def gncInvoiceGetPostedLot(invoice):
    r"""gncInvoiceGetPostedLot(GncInvoice const * invoice) -> GNCLot *"""
    return _gnucash_core_c.gncInvoiceGetPostedLot(invoice)

def gncInvoiceGetPostedTxn(invoice):
    r"""gncInvoiceGetPostedTxn(GncInvoice const * invoice) -> Transaction *"""
    return _gnucash_core_c.gncInvoiceGetPostedTxn(invoice)

def gncInvoiceGetPostedAcc(invoice):
    r"""gncInvoiceGetPostedAcc(GncInvoice const * invoice) -> Account *"""
    return _gnucash_core_c.gncInvoiceGetPostedAcc(invoice)

def gncInvoiceGetTotal(invoice):
    r"""gncInvoiceGetTotal(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotal(invoice)

def gncInvoiceGetTotalOf(invoice, type):
    r"""gncInvoiceGetTotalOf(GncInvoice * invoice, GncEntryPaymentType type) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalOf(invoice, type)

def gncInvoiceGetTotalSubtotal(invoice):
    r"""gncInvoiceGetTotalSubtotal(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalSubtotal(invoice)

def gncInvoiceGetTotalTax(invoice):
    r"""gncInvoiceGetTotalTax(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalTax(invoice)

def gncInvoiceGetTotalTaxList(invoice):
    r"""gncInvoiceGetTotalTaxList(GncInvoice * invoice) -> AccountValueList *"""
    return _gnucash_core_c.gncInvoiceGetTotalTaxList(invoice)

def gncInvoiceGetEntries(invoice):
    r"""gncInvoiceGetEntries(GncInvoice * invoice) -> EntryList *"""
    return _gnucash_core_c.gncInvoiceGetEntries(invoice)

def gncInvoiceGetPrice(invoice, commodity):
    r"""gncInvoiceGetPrice(GncInvoice * invoice, gnc_commodity * commodity) -> GNCPrice *"""
    return _gnucash_core_c.gncInvoiceGetPrice(invoice, commodity)

def gncInvoiceAmountPositive(invoice):
    r"""gncInvoiceAmountPositive(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceAmountPositive(invoice)

def gncInvoiceGetForeignCurrencies(invoice):
    r"""gncInvoiceGetForeignCurrencies(GncInvoice const * invoice) -> GHashTable *"""
    return _gnucash_core_c.gncInvoiceGetForeignCurrencies(invoice)

def gncInvoicePostToAccount(invoice, acc, posted_date, due_date, memo, accumulatesplits, autopay):
    r"""gncInvoicePostToAccount(GncInvoice * invoice, Account * acc, time64 posted_date, time64 due_date, char const * memo, gboolean accumulatesplits, gboolean autopay) -> Transaction *"""
    return _gnucash_core_c.gncInvoicePostToAccount(invoice, acc, posted_date, due_date, memo, accumulatesplits, autopay)

def gncInvoiceUnpost(invoice, reset_tax_tables):
    r"""gncInvoiceUnpost(GncInvoice * invoice, gboolean reset_tax_tables) -> gboolean"""
    return _gnucash_core_c.gncInvoiceUnpost(invoice, reset_tax_tables)

def gncInvoiceAutoApplyPayments(invoice):
    r"""gncInvoiceAutoApplyPayments(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceAutoApplyPayments(invoice)

def gncInvoiceApplyPayment(invoice, txn, xfer_acc, amount, exch, date, memo, num):
    r"""gncInvoiceApplyPayment(GncInvoice const * invoice, Transaction * txn, Account * xfer_acc, _gnc_numeric amount, _gnc_numeric exch, time64 date, char const * memo, char const * num)"""
    return _gnucash_core_c.gncInvoiceApplyPayment(invoice, txn, xfer_acc, amount, exch, date, memo, num)

def gncInvoiceGetInvoiceFromTxn(txn):
    r"""gncInvoiceGetInvoiceFromTxn(Transaction const * txn) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceGetInvoiceFromTxn(txn)

def gncInvoiceGetInvoiceFromLot(lot):
    r"""gncInvoiceGetInvoiceFromLot(GNCLot * lot) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceGetInvoiceFromLot(lot)

def gncInvoiceLookup(book, guid):
    r"""gncInvoiceLookup(QofBook const * book, GncGUID guid) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceLookup(book, guid)

def gncInvoiceBeginEdit(invoice):
    r"""gncInvoiceBeginEdit(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceBeginEdit(invoice)

def gncInvoiceCommitEdit(invoice):
    r"""gncInvoiceCommitEdit(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceCommitEdit(invoice)

def gncInvoiceCompare(a, b):
    r"""gncInvoiceCompare(GncInvoice const * a, GncInvoice const * b) -> int"""
    return _gnucash_core_c.gncInvoiceCompare(a, b)

def gncInvoiceIsPosted(invoice):
    r"""gncInvoiceIsPosted(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceIsPosted(invoice)

def gncInvoiceIsPaid(invoice):
    r"""gncInvoiceIsPaid(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceIsPaid(invoice)
INVOICE_ID = _gnucash_core_c.INVOICE_ID

INVOICE_OWNER = _gnucash_core_c.INVOICE_OWNER

INVOICE_OPENED = _gnucash_core_c.INVOICE_OPENED

INVOICE_POSTED = _gnucash_core_c.INVOICE_POSTED

INVOICE_DUE = _gnucash_core_c.INVOICE_DUE

INVOICE_IS_POSTED = _gnucash_core_c.INVOICE_IS_POSTED

INVOICE_IS_PAID = _gnucash_core_c.INVOICE_IS_PAID

INVOICE_TERMS = _gnucash_core_c.INVOICE_TERMS

INVOICE_BILLINGID = _gnucash_core_c.INVOICE_BILLINGID

INVOICE_NOTES = _gnucash_core_c.INVOICE_NOTES

INVOICE_DOCLINK = _gnucash_core_c.INVOICE_DOCLINK

INVOICE_ACC = _gnucash_core_c.INVOICE_ACC

INVOICE_POST_TXN = _gnucash_core_c.INVOICE_POST_TXN

INVOICE_POST_LOT = _gnucash_core_c.INVOICE_POST_LOT

INVOICE_IS_CN = _gnucash_core_c.INVOICE_IS_CN

INVOICE_TYPE = _gnucash_core_c.INVOICE_TYPE

INVOICE_TYPE_STRING = _gnucash_core_c.INVOICE_TYPE_STRING

INVOICE_BILLTO = _gnucash_core_c.INVOICE_BILLTO

INVOICE_JOB = _gnucash_core_c.INVOICE_JOB

INVOICE_FROM_LOT = _gnucash_core_c.INVOICE_FROM_LOT

INVOICE_FROM_TXN = _gnucash_core_c.INVOICE_FROM_TXN


def gncInvoiceGetBook(x):
    r"""gncInvoiceGetBook(GncInvoice * x) -> QofBook *"""
    return _gnucash_core_c.gncInvoiceGetBook(x)

def gncInvoiceEqual(a, b):
    r"""gncInvoiceEqual(GncInvoice const * a, GncInvoice const * b) -> gboolean"""
    return _gnucash_core_c.gncInvoiceEqual(a, b)

def gncInvoiceRegister():
    r"""gncInvoiceRegister() -> gboolean"""
    return _gnucash_core_c.gncInvoiceRegister()

def gncInvoiceNextID(book, owner):
    r"""gncInvoiceNextID(QofBook * book, GncOwner const * owner) -> gchar *"""
    return _gnucash_core_c.gncInvoiceNextID(book, owner)

def gncInvoiceSetPostedAcc(invoice, acc):
    r"""gncInvoiceSetPostedAcc(GncInvoice * invoice, Account * acc)"""
    return _gnucash_core_c.gncInvoiceSetPostedAcc(invoice, acc)

def gncInvoiceSetPostedTxn(invoice, txn):
    r"""gncInvoiceSetPostedTxn(GncInvoice * invoice, Transaction * txn)"""
    return _gnucash_core_c.gncInvoiceSetPostedTxn(invoice, txn)

def gncInvoiceSetPostedLot(invoice, lot):
    r"""gncInvoiceSetPostedLot(GncInvoice * invoice, GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceSetPostedLot(invoice, lot)

def gncInvoiceAttachToLot(invoice, lot):
    r"""gncInvoiceAttachToLot(GncInvoice * invoice, GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceAttachToLot(invoice, lot)

def gncInvoiceDetachFromLot(lot):
    r"""gncInvoiceDetachFromLot(GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceDetachFromLot(lot)

def gncInvoiceAttachToTxn(invoice, txn):
    r"""gncInvoiceAttachToTxn(GncInvoice * invoice, Transaction * txn)"""
    return _gnucash_core_c.gncInvoiceAttachToTxn(invoice, txn)
GNC_ID_JOB = _gnucash_core_c.GNC_ID_JOB


def gnc_job_get_type():
    r"""gnc_job_get_type() -> GType"""
    return _gnucash_core_c.gnc_job_get_type()

def gncJobCreate(book):
    r"""gncJobCreate(QofBook * book) -> GncJob *"""
    return _gnucash_core_c.gncJobCreate(book)

def gncJobDestroy(job):
    r"""gncJobDestroy(GncJob * job)"""
    return _gnucash_core_c.gncJobDestroy(job)

def gncJobFreeList(jobs):
    r"""gncJobFreeList(GList * jobs)"""
    return _gnucash_core_c.gncJobFreeList(jobs)

def gncJobSetID(job, id):
    r"""gncJobSetID(GncJob * job, char const * id)"""
    return _gnucash_core_c.gncJobSetID(job, id)

def gncJobSetName(job, jobname):
    r"""gncJobSetName(GncJob * job, char const * jobname)"""
    return _gnucash_core_c.gncJobSetName(job, jobname)

def gncJobSetReference(job, owner_reference):
    r"""gncJobSetReference(GncJob * job, char const * owner_reference)"""
    return _gnucash_core_c.gncJobSetReference(job, owner_reference)

def gncJobSetRate(job, rate):
    r"""gncJobSetRate(GncJob * job, _gnc_numeric rate)"""
    return _gnucash_core_c.gncJobSetRate(job, rate)

def gncJobSetOwner(job, owner):
    r"""gncJobSetOwner(GncJob * job, GncOwner * owner)"""
    return _gnucash_core_c.gncJobSetOwner(job, owner)

def gncJobSetActive(job, active):
    r"""gncJobSetActive(GncJob * job, gboolean active)"""
    return _gnucash_core_c.gncJobSetActive(job, active)

def gncJobBeginEdit(job):
    r"""gncJobBeginEdit(GncJob * job)"""
    return _gnucash_core_c.gncJobBeginEdit(job)

def gncJobCommitEdit(job):
    r"""gncJobCommitEdit(GncJob * job)"""
    return _gnucash_core_c.gncJobCommitEdit(job)

def gncJobGetID(job):
    r"""gncJobGetID(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetID(job)

def gncJobGetName(job):
    r"""gncJobGetName(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetName(job)

def gncJobGetReference(job):
    r"""gncJobGetReference(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetReference(job)

def gncJobGetRate(job):
    r"""gncJobGetRate(GncJob const * job) -> _gnc_numeric"""
    return _gnucash_core_c.gncJobGetRate(job)

def gncJobGetOwner(job):
    r"""gncJobGetOwner(GncJob * job) -> GncOwner *"""
    return _gnucash_core_c.gncJobGetOwner(job)

def gncJobGetActive(job):
    r"""gncJobGetActive(GncJob const * job) -> gboolean"""
    return _gnucash_core_c.gncJobGetActive(job)

def gncJobLookup(book, guid):
    r"""gncJobLookup(QofBook const * book, GncGUID guid) -> GncJob *"""
    return _gnucash_core_c.gncJobLookup(book, guid)

def gncJobCompare(a, b):
    r"""gncJobCompare(GncJob const * a, GncJob const * b) -> int"""
    return _gnucash_core_c.gncJobCompare(a, b)

def gncJobEqual(a, b):
    r"""gncJobEqual(GncJob const * a, GncJob const * b) -> gboolean"""
    return _gnucash_core_c.gncJobEqual(a, b)
JOB_ID = _gnucash_core_c.JOB_ID

JOB_NAME = _gnucash_core_c.JOB_NAME

JOB_REFERENCE = _gnucash_core_c.JOB_REFERENCE

JOB_RATE = _gnucash_core_c.JOB_RATE

JOB_OWNER = _gnucash_core_c.JOB_OWNER

Q_JOB_OWNER = _gnucash_core_c.Q_JOB_OWNER

JOB_ACTIVE = _gnucash_core_c.JOB_ACTIVE

GNC_PAYMENT_CASH = _gnucash_core_c.GNC_PAYMENT_CASH

GNC_PAYMENT_CARD = _gnucash_core_c.GNC_PAYMENT_CARD

GNC_DISC_PRETAX = _gnucash_core_c.GNC_DISC_PRETAX

GNC_DISC_SAMETIME = _gnucash_core_c.GNC_DISC_SAMETIME

GNC_DISC_POSTTAX = _gnucash_core_c.GNC_DISC_POSTTAX

GNC_ID_ENTRY = _gnucash_core_c.GNC_ID_ENTRY


def gnc_entry_get_type():
    r"""gnc_entry_get_type() -> GType"""
    return _gnucash_core_c.gnc_entry_get_type()

def gncEntryDiscountHowToString(how):
    r"""gncEntryDiscountHowToString(GncDiscountHow how) -> char const *"""
    return _gnucash_core_c.gncEntryDiscountHowToString(how)

def gncEntryDiscountStringToHow(str, how):
    r"""gncEntryDiscountStringToHow(char const * str, GncDiscountHow * how) -> gboolean"""
    return _gnucash_core_c.gncEntryDiscountStringToHow(str, how)

def gncEntryPaymentTypeToString(type):
    r"""gncEntryPaymentTypeToString(GncEntryPaymentType type) -> char const *"""
    return _gnucash_core_c.gncEntryPaymentTypeToString(type)

def gncEntryPaymentStringToType(str, type):
    r"""gncEntryPaymentStringToType(char const * str, GncEntryPaymentType * type) -> gboolean"""
    return _gnucash_core_c.gncEntryPaymentStringToType(str, type)

def gncEntryCreate(book):
    r"""gncEntryCreate(QofBook * book) -> GncEntry *"""
    return _gnucash_core_c.gncEntryCreate(book)

def gncEntryDestroy(entry):
    r"""gncEntryDestroy(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryDestroy(entry)

def gncEntrySetDateGDate(entry, date):
    r"""gncEntrySetDateGDate(GncEntry * entry, GDate const * date)"""
    return _gnucash_core_c.gncEntrySetDateGDate(entry, date)

def gncEntrySetDate(entry, date):
    r"""gncEntrySetDate(GncEntry * entry, time64 date)"""
    return _gnucash_core_c.gncEntrySetDate(entry, date)

def gncEntrySetDateEntered(entry, date):
    r"""gncEntrySetDateEntered(GncEntry * entry, time64 date)"""
    return _gnucash_core_c.gncEntrySetDateEntered(entry, date)

def gncEntrySetDescription(entry, desc):
    r"""gncEntrySetDescription(GncEntry * entry, char const * desc)"""
    return _gnucash_core_c.gncEntrySetDescription(entry, desc)

def gncEntrySetAction(entry, action):
    r"""gncEntrySetAction(GncEntry * entry, char const * action)"""
    return _gnucash_core_c.gncEntrySetAction(entry, action)

def gncEntrySetNotes(entry, notes):
    r"""gncEntrySetNotes(GncEntry * entry, char const * notes)"""
    return _gnucash_core_c.gncEntrySetNotes(entry, notes)

def gncEntrySetQuantity(entry, quantity):
    r"""gncEntrySetQuantity(GncEntry * entry, _gnc_numeric quantity)"""
    return _gnucash_core_c.gncEntrySetQuantity(entry, quantity)

def gncEntrySetDocQuantity(entry, quantity, is_cn):
    r"""gncEntrySetDocQuantity(GncEntry * entry, _gnc_numeric quantity, gboolean is_cn)"""
    return _gnucash_core_c.gncEntrySetDocQuantity(entry, quantity, is_cn)

def gncEntrySetInvAccount(entry, acc):
    r"""gncEntrySetInvAccount(GncEntry * entry, Account * acc)"""
    return _gnucash_core_c.gncEntrySetInvAccount(entry, acc)

def gncEntrySetInvPrice(entry, price):
    r"""gncEntrySetInvPrice(GncEntry * entry, _gnc_numeric price)"""
    return _gnucash_core_c.gncEntrySetInvPrice(entry, price)

def gncEntrySetInvTaxable(entry, taxable):
    r"""gncEntrySetInvTaxable(GncEntry * entry, gboolean taxable)"""
    return _gnucash_core_c.gncEntrySetInvTaxable(entry, taxable)

def gncEntrySetInvTaxIncluded(entry, tax_included):
    r"""gncEntrySetInvTaxIncluded(GncEntry * entry, gboolean tax_included)"""
    return _gnucash_core_c.gncEntrySetInvTaxIncluded(entry, tax_included)

def gncEntrySetInvTaxTable(entry, table):
    r"""gncEntrySetInvTaxTable(GncEntry * entry, GncTaxTable * table)"""
    return _gnucash_core_c.gncEntrySetInvTaxTable(entry, table)

def gncEntrySetInvDiscount(entry, discount):
    r"""gncEntrySetInvDiscount(GncEntry * entry, _gnc_numeric discount)"""
    return _gnucash_core_c.gncEntrySetInvDiscount(entry, discount)

def gncEntrySetInvDiscountType(entry, type):
    r"""gncEntrySetInvDiscountType(GncEntry * entry, GncAmountType type)"""
    return _gnucash_core_c.gncEntrySetInvDiscountType(entry, type)

def gncEntrySetInvDiscountHow(entry, how):
    r"""gncEntrySetInvDiscountHow(GncEntry * entry, GncDiscountHow how)"""
    return _gnucash_core_c.gncEntrySetInvDiscountHow(entry, how)

def qofEntrySetInvDiscType(entry, type):
    r"""qofEntrySetInvDiscType(GncEntry * entry, char const * type)"""
    return _gnucash_core_c.qofEntrySetInvDiscType(entry, type)

def qofEntrySetInvDiscHow(entry, type):
    r"""qofEntrySetInvDiscHow(GncEntry * entry, char const * type)"""
    return _gnucash_core_c.qofEntrySetInvDiscHow(entry, type)

def gncEntrySetBillAccount(entry, acc):
    r"""gncEntrySetBillAccount(GncEntry * entry, Account * acc)"""
    return _gnucash_core_c.gncEntrySetBillAccount(entry, acc)

def gncEntrySetBillPrice(entry, price):
    r"""gncEntrySetBillPrice(GncEntry * entry, _gnc_numeric price)"""
    return _gnucash_core_c.gncEntrySetBillPrice(entry, price)

def gncEntrySetBillTaxable(entry, taxable):
    r"""gncEntrySetBillTaxable(GncEntry * entry, gboolean taxable)"""
    return _gnucash_core_c.gncEntrySetBillTaxable(entry, taxable)

def gncEntrySetBillTaxIncluded(entry, tax_included):
    r"""gncEntrySetBillTaxIncluded(GncEntry * entry, gboolean tax_included)"""
    return _gnucash_core_c.gncEntrySetBillTaxIncluded(entry, tax_included)

def gncEntrySetBillTaxTable(entry, table):
    r"""gncEntrySetBillTaxTable(GncEntry * entry, GncTaxTable * table)"""
    return _gnucash_core_c.gncEntrySetBillTaxTable(entry, table)

def gncEntrySetBillable(entry, billable):
    r"""gncEntrySetBillable(GncEntry * entry, gboolean billable)"""
    return _gnucash_core_c.gncEntrySetBillable(entry, billable)

def gncEntrySetBillTo(entry, billto):
    r"""gncEntrySetBillTo(GncEntry * entry, GncOwner * billto)"""
    return _gnucash_core_c.gncEntrySetBillTo(entry, billto)

def gncEntrySetBillPayment(entry, type):
    r"""gncEntrySetBillPayment(GncEntry * entry, GncEntryPaymentType type)"""
    return _gnucash_core_c.gncEntrySetBillPayment(entry, type)

def gncEntryGetDateGDate(entry):
    r"""gncEntryGetDateGDate(GncEntry const * entry) -> GDate"""
    return _gnucash_core_c.gncEntryGetDateGDate(entry)

def gncEntryGetDate(entry):
    r"""gncEntryGetDate(GncEntry const * entry) -> time64"""
    return _gnucash_core_c.gncEntryGetDate(entry)

def gncEntryGetDateEntered(entry):
    r"""gncEntryGetDateEntered(GncEntry const * entry) -> time64"""
    return _gnucash_core_c.gncEntryGetDateEntered(entry)

def gncEntryGetDescription(entry):
    r"""gncEntryGetDescription(GncEntry const * entry) -> char const *"""
    return _gnucash_core_c.gncEntryGetDescription(entry)

def gncEntryGetAction(entry):
    r"""gncEntryGetAction(GncEntry const * entry) -> char const *"""
    return _gnucash_core_c.gncEntryGetAction(entry)

def gncEntryGetNotes(notes):
    r"""gncEntryGetNotes(GncEntry const * notes) -> char const *"""
    return _gnucash_core_c.gncEntryGetNotes(notes)

def gncEntryGetQuantity(entry):
    r"""gncEntryGetQuantity(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetQuantity(entry)

def gncEntryGetDocQuantity(entry, is_cn):
    r"""gncEntryGetDocQuantity(GncEntry const * entry, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocQuantity(entry, is_cn)

def gncEntryGetInvAccount(entry):
    r"""gncEntryGetInvAccount(GncEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncEntryGetInvAccount(entry)

def gncEntryGetInvPrice(entry):
    r"""gncEntryGetInvPrice(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetInvPrice(entry)

def gncEntryGetPrice(entry, cust_doc, net):
    r"""gncEntryGetPrice(GncEntry const * entry, gboolean const cust_doc, gboolean const net) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetPrice(entry, cust_doc, net)

def gncEntryGetInvDiscount(entry):
    r"""gncEntryGetInvDiscount(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetInvDiscount(entry)

def gncEntryGetInvDiscountType(entry):
    r"""gncEntryGetInvDiscountType(GncEntry const * entry) -> GncAmountType"""
    return _gnucash_core_c.gncEntryGetInvDiscountType(entry)

def gncEntryGetInvDiscountHow(entry):
    r"""gncEntryGetInvDiscountHow(GncEntry const * entry) -> GncDiscountHow"""
    return _gnucash_core_c.gncEntryGetInvDiscountHow(entry)

def qofEntryGetInvDiscType(entry):
    r"""qofEntryGetInvDiscType(GncEntry const * entry) -> char *"""
    return _gnucash_core_c.qofEntryGetInvDiscType(entry)

def qofEntryGetInvDiscHow(entry):
    r"""qofEntryGetInvDiscHow(GncEntry const * entry) -> char *"""
    return _gnucash_core_c.qofEntryGetInvDiscHow(entry)

def gncEntryGetInvTaxable(entry):
    r"""gncEntryGetInvTaxable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetInvTaxable(entry)

def gncEntryGetInvTaxIncluded(entry):
    r"""gncEntryGetInvTaxIncluded(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetInvTaxIncluded(entry)

def gncEntryGetInvTaxTable(entry):
    r"""gncEntryGetInvTaxTable(GncEntry const * entry) -> GncTaxTable *"""
    return _gnucash_core_c.gncEntryGetInvTaxTable(entry)

def gncEntryGetBillAccount(entry):
    r"""gncEntryGetBillAccount(GncEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncEntryGetBillAccount(entry)

def gncEntryGetBillPrice(entry):
    r"""gncEntryGetBillPrice(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBillPrice(entry)

def gncEntryGetBillTaxable(entry):
    r"""gncEntryGetBillTaxable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillTaxable(entry)

def gncEntryGetBillTaxIncluded(entry):
    r"""gncEntryGetBillTaxIncluded(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillTaxIncluded(entry)

def gncEntryGetBillTaxTable(entry):
    r"""gncEntryGetBillTaxTable(GncEntry const * entry) -> GncTaxTable *"""
    return _gnucash_core_c.gncEntryGetBillTaxTable(entry)

def gncEntryGetBillable(entry):
    r"""gncEntryGetBillable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillable(entry)

def gncEntryGetBillTo(entry):
    r"""gncEntryGetBillTo(GncEntry * entry) -> GncOwner *"""
    return _gnucash_core_c.gncEntryGetBillTo(entry)

def gncEntryGetBillPayment(entry):
    r"""gncEntryGetBillPayment(GncEntry const * entry) -> GncEntryPaymentType"""
    return _gnucash_core_c.gncEntryGetBillPayment(entry)

def gncEntryCopy(src, dest, add_entry):
    r"""gncEntryCopy(GncEntry const * src, GncEntry * dest, gboolean add_entry)"""
    return _gnucash_core_c.gncEntryCopy(src, dest, add_entry)

def gncEntryGetDocValue(entry, round, is_cust_doc, is_cn):
    r"""gncEntryGetDocValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocValue(entry, round, is_cust_doc, is_cn)

def gncEntryGetDocTaxValue(entry, round, is_cust_doc, is_cn):
    r"""gncEntryGetDocTaxValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocTaxValue(entry, round, is_cust_doc, is_cn)

def gncEntryGetDocTaxValues(entry, is_cust_doc, is_cn):
    r"""gncEntryGetDocTaxValues(GncEntry * entry, gboolean is_cust_doc, gboolean is_cn) -> AccountValueList *"""
    return _gnucash_core_c.gncEntryGetDocTaxValues(entry, is_cust_doc, is_cn)

def gncEntryGetDocDiscountValue(entry, round, is_cust_doc, is_cn):
    r"""gncEntryGetDocDiscountValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocDiscountValue(entry, round, is_cust_doc, is_cn)

def gncEntryGetBalValue(entry, round, is_cust_doc):
    r"""gncEntryGetBalValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalValue(entry, round, is_cust_doc)

def gncEntryGetBalTaxValue(entry, round, is_cust_doc):
    r"""gncEntryGetBalTaxValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalTaxValue(entry, round, is_cust_doc)

def gncEntryGetBalTaxValues(entry, is_cust_doc):
    r"""gncEntryGetBalTaxValues(GncEntry * entry, gboolean is_cust_doc) -> AccountValueList *"""
    return _gnucash_core_c.gncEntryGetBalTaxValues(entry, is_cust_doc)

def gncEntryGetBalDiscountValue(entry, round, is_cust_doc):
    r"""gncEntryGetBalDiscountValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalDiscountValue(entry, round, is_cust_doc)

def gncEntryComputeValue(qty, price, tax_table, tax_included, discount, discount_type, discount_how, SCU, value, discount_value, tax_values):
    r"""gncEntryComputeValue(_gnc_numeric qty, _gnc_numeric price, GncTaxTable const * tax_table, gboolean tax_included, _gnc_numeric discount, GncAmountType discount_type, GncDiscountHow discount_how, int SCU, _gnc_numeric value, _gnc_numeric discount_value, GList ** tax_values)"""
    return _gnucash_core_c.gncEntryComputeValue(qty, price, tax_table, tax_included, discount, discount_type, discount_how, SCU, value, discount_value, tax_values)

def gncEntryGetOrder(entry):
    r"""gncEntryGetOrder(GncEntry const * entry) -> GncOrder *"""
    return _gnucash_core_c.gncEntryGetOrder(entry)

def gncEntryGetInvoice(entry):
    r"""gncEntryGetInvoice(GncEntry const * entry) -> GncInvoice *"""
    return _gnucash_core_c.gncEntryGetInvoice(entry)

def gncEntryGetBill(entry):
    r"""gncEntryGetBill(GncEntry const * entry) -> GncInvoice *"""
    return _gnucash_core_c.gncEntryGetBill(entry)

def gncEntryLookup(book, guid):
    r"""gncEntryLookup(QofBook const * book, GncGUID guid) -> GncEntry *"""
    return _gnucash_core_c.gncEntryLookup(book, guid)

def gncEntryIsOpen(entry):
    r"""gncEntryIsOpen(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryIsOpen(entry)

def gncEntryBeginEdit(entry):
    r"""gncEntryBeginEdit(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryBeginEdit(entry)

def gncEntryCommitEdit(entry):
    r"""gncEntryCommitEdit(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryCommitEdit(entry)

def gncEntryCompare(a, b):
    r"""gncEntryCompare(GncEntry const * a, GncEntry const * b) -> int"""
    return _gnucash_core_c.gncEntryCompare(a, b)
ENTRY_DATE = _gnucash_core_c.ENTRY_DATE

ENTRY_DATE_ENTERED = _gnucash_core_c.ENTRY_DATE_ENTERED

ENTRY_DESC = _gnucash_core_c.ENTRY_DESC

ENTRY_ACTION = _gnucash_core_c.ENTRY_ACTION

ENTRY_NOTES = _gnucash_core_c.ENTRY_NOTES

ENTRY_QTY = _gnucash_core_c.ENTRY_QTY

ENTRY_IPRICE = _gnucash_core_c.ENTRY_IPRICE

ENTRY_IACCT = _gnucash_core_c.ENTRY_IACCT

ENTRY_BACCT = _gnucash_core_c.ENTRY_BACCT

ENTRY_BPRICE = _gnucash_core_c.ENTRY_BPRICE

ENTRY_BILLABLE = _gnucash_core_c.ENTRY_BILLABLE

ENTRY_BILLTO = _gnucash_core_c.ENTRY_BILLTO

ENTRY_ORDER = _gnucash_core_c.ENTRY_ORDER

ENTRY_INVOICE = _gnucash_core_c.ENTRY_INVOICE

ENTRY_BILL = _gnucash_core_c.ENTRY_BILL

ENTRY_INV_DISC_TYPE = _gnucash_core_c.ENTRY_INV_DISC_TYPE

ENTRY_INV_DISC_HOW = _gnucash_core_c.ENTRY_INV_DISC_HOW

ENTRY_INV_TAXABLE = _gnucash_core_c.ENTRY_INV_TAXABLE

ENTRY_BILL_TAXABLE = _gnucash_core_c.ENTRY_BILL_TAXABLE

ENTRY_INV_TAX_INC = _gnucash_core_c.ENTRY_INV_TAX_INC

ENTRY_BILL_TAX_INC = _gnucash_core_c.ENTRY_BILL_TAX_INC

ENTRY_INV_DISCOUNT = _gnucash_core_c.ENTRY_INV_DISCOUNT

ENTRY_BILL_PAY_TYPE = _gnucash_core_c.ENTRY_BILL_PAY_TYPE

GNC_AMT_TYPE_VALUE = _gnucash_core_c.GNC_AMT_TYPE_VALUE

GNC_AMT_TYPE_PERCENT = _gnucash_core_c.GNC_AMT_TYPE_PERCENT

GNC_TAXINCLUDED_YES = _gnucash_core_c.GNC_TAXINCLUDED_YES

GNC_TAXINCLUDED_NO = _gnucash_core_c.GNC_TAXINCLUDED_NO

GNC_TAXINCLUDED_USEGLOBAL = _gnucash_core_c.GNC_TAXINCLUDED_USEGLOBAL

GNC_ID_TAXTABLE = _gnucash_core_c.GNC_ID_TAXTABLE


def gnc_taxtable_get_type():
    r"""gnc_taxtable_get_type() -> GType"""
    return _gnucash_core_c.gnc_taxtable_get_type()

def gncAmountTypeToString(type):
    r"""gncAmountTypeToString(GncAmountType type) -> char const *"""
    return _gnucash_core_c.gncAmountTypeToString(type)

def gncAmountStringToType(str, type):
    r"""gncAmountStringToType(char const * str, GncAmountType * type) -> gboolean"""
    return _gnucash_core_c.gncAmountStringToType(str, type)

def gncTaxIncludedTypeToString(type):
    r"""gncTaxIncludedTypeToString(GncTaxIncluded type) -> char const *"""
    return _gnucash_core_c.gncTaxIncludedTypeToString(type)

def gncTaxIncludedStringToType(str, type):
    r"""gncTaxIncludedStringToType(char const * str, GncTaxIncluded * type) -> gboolean"""
    return _gnucash_core_c.gncTaxIncludedStringToType(str, type)

def gncTaxTableCreate(book):
    r"""gncTaxTableCreate(QofBook * book) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableCreate(book)

def gncTaxTableDestroy(table):
    r"""gncTaxTableDestroy(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableDestroy(table)

def gncTaxTableEntryCreate():
    r"""gncTaxTableEntryCreate() -> GncTaxTableEntry *"""
    return _gnucash_core_c.gncTaxTableEntryCreate()

def gncTaxTableEntryDestroy(entry):
    r"""gncTaxTableEntryDestroy(GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableEntryDestroy(entry)

def gncTaxTableSetName(table, name):
    r"""gncTaxTableSetName(GncTaxTable * table, char const * name)"""
    return _gnucash_core_c.gncTaxTableSetName(table, name)

def gncTaxTableIncRef(table):
    r"""gncTaxTableIncRef(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableIncRef(table)

def gncTaxTableDecRef(table):
    r"""gncTaxTableDecRef(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableDecRef(table)

def gncTaxTableEntrySetAccount(entry, account):
    r"""gncTaxTableEntrySetAccount(GncTaxTableEntry * entry, Account * account)"""
    return _gnucash_core_c.gncTaxTableEntrySetAccount(entry, account)

def gncTaxTableEntrySetType(entry, type):
    r"""gncTaxTableEntrySetType(GncTaxTableEntry * entry, GncAmountType type)"""
    return _gnucash_core_c.gncTaxTableEntrySetType(entry, type)

def gncTaxTableEntrySetAmount(entry, amount):
    r"""gncTaxTableEntrySetAmount(GncTaxTableEntry * entry, _gnc_numeric amount)"""
    return _gnucash_core_c.gncTaxTableEntrySetAmount(entry, amount)

def gncTaxTableAddEntry(table, entry):
    r"""gncTaxTableAddEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableAddEntry(table, entry)

def gncTaxTableRemoveEntry(table, entry):
    r"""gncTaxTableRemoveEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableRemoveEntry(table, entry)

def gncTaxTableChanged(table):
    r"""gncTaxTableChanged(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableChanged(table)

def gncTaxTableBeginEdit(table):
    r"""gncTaxTableBeginEdit(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableBeginEdit(table)

def gncTaxTableCommitEdit(table):
    r"""gncTaxTableCommitEdit(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableCommitEdit(table)

def gncTaxTableEqual(a, b):
    r"""gncTaxTableEqual(GncTaxTable const * a, GncTaxTable const * b) -> gboolean"""
    return _gnucash_core_c.gncTaxTableEqual(a, b)

def gncTaxTableLookup(book, guid):
    r"""gncTaxTableLookup(QofBook const * book, GncGUID guid) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableLookup(book, guid)

def gncTaxTableLookupByName(book, name):
    r"""gncTaxTableLookupByName(QofBook * book, char const * name) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableLookupByName(book, name)

def gncTaxTableGetDefault(book, type):
    r"""gncTaxTableGetDefault(QofBook * book, GncOwnerType type) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableGetDefault(book, type)

def gncTaxTableGetTables(book):
    r"""gncTaxTableGetTables(QofBook * book) -> GncTaxTableList *"""
    return _gnucash_core_c.gncTaxTableGetTables(book)

def gncTaxTableGetName(table):
    r"""gncTaxTableGetName(GncTaxTable const * table) -> char const *"""
    return _gnucash_core_c.gncTaxTableGetName(table)

def gncTaxTableGetParent(table):
    r"""gncTaxTableGetParent(GncTaxTable const * table) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableGetParent(table)

def gncTaxTableReturnChild(table, make_new):
    r"""gncTaxTableReturnChild(GncTaxTable * table, gboolean make_new) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableReturnChild(table, make_new)

def gncTaxTableGetEntries(table):
    r"""gncTaxTableGetEntries(GncTaxTable const * table) -> GncTaxTableEntryList *"""
    return _gnucash_core_c.gncTaxTableGetEntries(table)

def gncTaxTableGetRefcount(table):
    r"""gncTaxTableGetRefcount(GncTaxTable const * table) -> gint64"""
    return _gnucash_core_c.gncTaxTableGetRefcount(table)

def gncTaxTableLastModifiedSecs(table):
    r"""gncTaxTableLastModifiedSecs(GncTaxTable const * table) -> time64"""
    return _gnucash_core_c.gncTaxTableLastModifiedSecs(table)

def gncTaxTableEntryGetAccount(entry):
    r"""gncTaxTableEntryGetAccount(GncTaxTableEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncTaxTableEntryGetAccount(entry)

def gncTaxTableEntryGetType(entry):
    r"""gncTaxTableEntryGetType(GncTaxTableEntry const * entry) -> GncAmountType"""
    return _gnucash_core_c.gncTaxTableEntryGetType(entry)

def gncTaxTableEntryGetAmount(entry):
    r"""gncTaxTableEntryGetAmount(GncTaxTableEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncTaxTableEntryGetAmount(entry)

def gncTaxTableCompare(a, b):
    r"""gncTaxTableCompare(GncTaxTable const * a, GncTaxTable const * b) -> int"""
    return _gnucash_core_c.gncTaxTableCompare(a, b)

def gncTaxTableEntryCompare(a, b):
    r"""gncTaxTableEntryCompare(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> int"""
    return _gnucash_core_c.gncTaxTableEntryCompare(a, b)

def gncTaxTableEntryEqual(a, b):
    r"""gncTaxTableEntryEqual(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> gboolean"""
    return _gnucash_core_c.gncTaxTableEntryEqual(a, b)
class _gncAccountValue(object):
    r"""Proxy of C _gncAccountValue struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    account = property(_gnucash_core_c._gncAccountValue_account_get, _gnucash_core_c._gncAccountValue_account_set, doc=r"""account : p.Account""")
    value = property(_gnucash_core_c._gncAccountValue_value_get, _gnucash_core_c._gncAccountValue_value_set, doc=r"""value : gnc_numeric""")

    def __init__(self):
        r"""__init__(_gncAccountValue self) -> _gncAccountValue"""
        _gnucash_core_c._gncAccountValue_swiginit(self, _gnucash_core_c.new__gncAccountValue())
    __swig_destroy__ = _gnucash_core_c.delete__gncAccountValue

# Register _gncAccountValue in _gnucash_core_c:
_gnucash_core_c._gncAccountValue_swigregister(_gncAccountValue)

def gncAccountValueAdd(list, acc, value):
    r"""gncAccountValueAdd(GList * list, Account * acc, _gnc_numeric value) -> GList *"""
    return _gnucash_core_c.gncAccountValueAdd(list, acc, value)

def gncAccountValueAddList(l1, l2):
    r"""gncAccountValueAddList(GList * l1, GList * l2) -> GList *"""
    return _gnucash_core_c.gncAccountValueAddList(l1, l2)

def gncAccountValueTotal(list):
    r"""gncAccountValueTotal(GList * list) -> _gnc_numeric"""
    return _gnucash_core_c.gncAccountValueTotal(list)

def gncAccountValueDestroy(list):
    r"""gncAccountValueDestroy(GList * list)"""
    return _gnucash_core_c.gncAccountValueDestroy(list)
GNC_TT_NAME = _gnucash_core_c.GNC_TT_NAME

GNC_TT_REFCOUNT = _gnucash_core_c.GNC_TT_REFCOUNT


def gnc_search_customer_on_id(book, id):
    r"""gnc_search_customer_on_id(QofBook * book, gchar const * id) -> GncCustomer *"""
    return _gnucash_core_c.gnc_search_customer_on_id(book, id)

def gnc_search_invoice_on_id(book, id):
    r"""gnc_search_invoice_on_id(QofBook * book, gchar const * id) -> GncInvoice *"""
    return _gnucash_core_c.gnc_search_invoice_on_id(book, id)

def gnc_search_bill_on_id(book, id):
    r"""gnc_search_bill_on_id(QofBook * book, gchar const * id) -> GncInvoice *"""
    return _gnucash_core_c.gnc_search_bill_on_id(book, id)

def gnc_search_vendor_on_id(book, id):
    r"""gnc_search_vendor_on_id(QofBook * book, gchar const * id) -> GncVendor *"""
    return _gnucash_core_c.gnc_search_vendor_on_id(book, id)

def gnc_price_get_type():
    r"""gnc_price_get_type() -> GType"""
    return _gnucash_core_c.gnc_price_get_type()

def gnc_pricedb_get_type():
    r"""gnc_pricedb_get_type() -> GType"""
    return _gnucash_core_c.gnc_pricedb_get_type()
PRICE_SOURCE_EDIT_DLG = _gnucash_core_c.PRICE_SOURCE_EDIT_DLG

PRICE_SOURCE_FQ = _gnucash_core_c.PRICE_SOURCE_FQ

PRICE_SOURCE_USER_PRICE = _gnucash_core_c.PRICE_SOURCE_USER_PRICE

PRICE_SOURCE_XFER_DLG_VAL = _gnucash_core_c.PRICE_SOURCE_XFER_DLG_VAL

PRICE_SOURCE_SPLIT_REG = _gnucash_core_c.PRICE_SOURCE_SPLIT_REG

PRICE_SOURCE_SPLIT_IMPORT = _gnucash_core_c.PRICE_SOURCE_SPLIT_IMPORT

PRICE_SOURCE_STOCK_SPLIT = _gnucash_core_c.PRICE_SOURCE_STOCK_SPLIT

PRICE_SOURCE_STOCK_TRANSACTION = _gnucash_core_c.PRICE_SOURCE_STOCK_TRANSACTION

PRICE_SOURCE_INVOICE = _gnucash_core_c.PRICE_SOURCE_INVOICE

PRICE_SOURCE_TEMP = _gnucash_core_c.PRICE_SOURCE_TEMP

PRICE_SOURCE_INVALID = _gnucash_core_c.PRICE_SOURCE_INVALID

PRICE_TYPE_LAST = _gnucash_core_c.PRICE_TYPE_LAST

PRICE_TYPE_UNK = _gnucash_core_c.PRICE_TYPE_UNK

PRICE_TYPE_TRN = _gnucash_core_c.PRICE_TYPE_TRN


def gnc_price_create(book):
    r"""gnc_price_create(QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_create(book)

def gnc_price_clone(p, book):
    r"""gnc_price_clone(GNCPrice * p, QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_clone(p, book)

def gnc_price_invert(p):
    r"""gnc_price_invert(GNCPrice * p) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_invert(p)

def gnc_price_ref(p):
    r"""gnc_price_ref(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_ref(p)

def gnc_price_unref(p):
    r"""gnc_price_unref(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_unref(p)

def gnc_price_begin_edit(p):
    r"""gnc_price_begin_edit(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_begin_edit(p)

def gnc_price_commit_edit(p):
    r"""gnc_price_commit_edit(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_commit_edit(p)

def gnc_price_set_commodity(p, c):
    r"""gnc_price_set_commodity(GNCPrice * p, gnc_commodity * c)"""
    return _gnucash_core_c.gnc_price_set_commodity(p, c)

def gnc_price_set_currency(p, c):
    r"""gnc_price_set_currency(GNCPrice * p, gnc_commodity * c)"""
    return _gnucash_core_c.gnc_price_set_currency(p, c)

def gnc_price_set_time64(p, t):
    r"""gnc_price_set_time64(GNCPrice * p, time64 t)"""
    return _gnucash_core_c.gnc_price_set_time64(p, t)

def gnc_price_set_source(p, source):
    r"""gnc_price_set_source(GNCPrice * p, PriceSource source)"""
    return _gnucash_core_c.gnc_price_set_source(p, source)

def gnc_price_set_source_string(p, s):
    r"""gnc_price_set_source_string(GNCPrice * p, char const * s)"""
    return _gnucash_core_c.gnc_price_set_source_string(p, s)

def gnc_price_set_typestr(p, type):
    r"""gnc_price_set_typestr(GNCPrice * p, char const * type)"""
    return _gnucash_core_c.gnc_price_set_typestr(p, type)

def gnc_price_set_value(p, value):
    r"""gnc_price_set_value(GNCPrice * p, _gnc_numeric value)"""
    return _gnucash_core_c.gnc_price_set_value(p, value)

def gnc_price_lookup(guid, book):
    r"""gnc_price_lookup(GncGUID guid, QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_lookup(guid, book)

def gnc_price_get_commodity(p):
    r"""gnc_price_get_commodity(GNCPrice const * p) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_price_get_commodity(p)

def gnc_price_get_currency(p):
    r"""gnc_price_get_currency(GNCPrice const * p) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_price_get_currency(p)

def gnc_price_get_time64(p):
    r"""gnc_price_get_time64(GNCPrice const * p) -> time64"""
    return _gnucash_core_c.gnc_price_get_time64(p)

def gnc_price_get_source(p):
    r"""gnc_price_get_source(GNCPrice const * p) -> PriceSource"""
    return _gnucash_core_c.gnc_price_get_source(p)

def gnc_price_get_source_string(p):
    r"""gnc_price_get_source_string(GNCPrice const * p) -> char const *"""
    return _gnucash_core_c.gnc_price_get_source_string(p)

def gnc_price_get_typestr(p):
    r"""gnc_price_get_typestr(GNCPrice const * p) -> char const *"""
    return _gnucash_core_c.gnc_price_get_typestr(p)

def gnc_price_get_value(p):
    r"""gnc_price_get_value(GNCPrice const * p) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_price_get_value(p)

def gnc_price_equal(p1, p2):
    r"""gnc_price_equal(GNCPrice const * p1, GNCPrice const * p2) -> gboolean"""
    return _gnucash_core_c.gnc_price_equal(p1, p2)

def gnc_price_print(db, f, indent):
    r"""gnc_price_print(GNCPrice * db, FILE * f, int indent)"""
    return _gnucash_core_c.gnc_price_print(db, f, indent)
CURRENCY_DENOM = _gnucash_core_c.CURRENCY_DENOM

COMMODITY_DENOM_MULT = _gnucash_core_c.COMMODITY_DENOM_MULT


def gnc_price_list_insert(prices, p, check_dupl):
    r"""gnc_price_list_insert(PriceList ** prices, GNCPrice * p, gboolean check_dupl) -> gboolean"""
    return _gnucash_core_c.gnc_price_list_insert(prices, p, check_dupl)

def gnc_price_list_remove(prices, p):
    r"""gnc_price_list_remove(PriceList ** prices, GNCPrice * p) -> gboolean"""
    return _gnucash_core_c.gnc_price_list_remove(prices, p)

def gnc_price_list_destroy(prices):
    r"""gnc_price_list_destroy(PriceList * prices)"""
    return _gnucash_core_c.gnc_price_list_destroy(prices)

def gnc_price_list_equal(prices1, prices2):
    r"""gnc_price_list_equal(PriceList * prices1, PriceList * prices2) -> gboolean"""
    return _gnucash_core_c.gnc_price_list_equal(prices1, prices2)

def gnc_pricedb_get_db(book):
    r"""gnc_pricedb_get_db(QofBook * book) -> GNCPriceDB *"""
    return _gnucash_core_c.gnc_pricedb_get_db(book)

def gnc_collection_get_pricedb(col):
    r"""gnc_collection_get_pricedb(QofCollection * col) -> GNCPriceDB *"""
    return _gnucash_core_c.gnc_collection_get_pricedb(col)

def gnc_pricedb_destroy(db):
    r"""gnc_pricedb_destroy(GNCPriceDB * db)"""
    return _gnucash_core_c.gnc_pricedb_destroy(db)

def gnc_pricedb_begin_edit(arg1):
    r"""gnc_pricedb_begin_edit(GNCPriceDB * arg1)"""
    return _gnucash_core_c.gnc_pricedb_begin_edit(arg1)

def gnc_pricedb_commit_edit(arg1):
    r"""gnc_pricedb_commit_edit(GNCPriceDB * arg1)"""
    return _gnucash_core_c.gnc_pricedb_commit_edit(arg1)

def gnc_pricedb_set_bulk_update(db, bulk_update):
    r"""gnc_pricedb_set_bulk_update(GNCPriceDB * db, gboolean bulk_update)"""
    return _gnucash_core_c.gnc_pricedb_set_bulk_update(db, bulk_update)

def gnc_pricedb_add_price(db, p):
    r"""gnc_pricedb_add_price(GNCPriceDB * db, GNCPrice * p) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_add_price(db, p)

def gnc_pricedb_remove_price(db, p):
    r"""gnc_pricedb_remove_price(GNCPriceDB * db, GNCPrice * p) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_remove_price(db, p)
PRICE_REMOVE_SOURCE_FQ = _gnucash_core_c.PRICE_REMOVE_SOURCE_FQ

PRICE_REMOVE_SOURCE_USER = _gnucash_core_c.PRICE_REMOVE_SOURCE_USER

PRICE_REMOVE_SOURCE_APP = _gnucash_core_c.PRICE_REMOVE_SOURCE_APP

PRICE_REMOVE_SOURCE_COMM = _gnucash_core_c.PRICE_REMOVE_SOURCE_COMM

PRICE_REMOVE_KEEP_NONE = _gnucash_core_c.PRICE_REMOVE_KEEP_NONE

PRICE_REMOVE_KEEP_LAST_WEEKLY = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_WEEKLY

PRICE_REMOVE_KEEP_LAST_MONTHLY = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_MONTHLY

PRICE_REMOVE_KEEP_LAST_QUARTERLY = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_QUARTERLY

PRICE_REMOVE_KEEP_LAST_PERIOD = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_PERIOD

PRICE_REMOVE_KEEP_SCALED = _gnucash_core_c.PRICE_REMOVE_KEEP_SCALED


def gnc_pricedb_remove_old_prices(db, comm_list, fiscal_end_date, cutoff, source, keep):
    r"""gnc_pricedb_remove_old_prices(GNCPriceDB * db, GList * comm_list, GDate * fiscal_end_date, time64 cutoff, PriceRemoveSourceFlags source, PriceRemoveKeepOptions keep) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_remove_old_prices(db, comm_list, fiscal_end_date, cutoff, source, keep)

def gnc_pricedb_lookup_latest(db, commodity, currency):
    r"""gnc_pricedb_lookup_latest(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest(db, commodity, currency)

def gnc_pricedb_lookup_latest_any_currency(db, commodity):
    r"""gnc_pricedb_lookup_latest_any_currency(GNCPriceDB * db, gnc_commodity const * commodity) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest_any_currency(db, commodity)

def gnc_pricedb_has_prices(db, commodity, currency):
    r"""gnc_pricedb_has_prices(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_has_prices(db, commodity, currency)

def gnc_pricedb_get_prices(db, commodity, currency):
    r"""gnc_pricedb_get_prices(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_get_prices(db, commodity, currency)

def gnc_pricedb_lookup_day_t64(db, commodity, currency, t):
    r"""gnc_pricedb_lookup_day_t64(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_day_t64(db, commodity, currency, t)

def gnc_pricedb_lookup_nearest_in_time64(db, c, currency, t):
    r"""gnc_pricedb_lookup_nearest_in_time64(GNCPriceDB * db, gnc_commodity const * c, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_nearest_in_time64(db, c, currency, t)

def gnc_pricedb_lookup_nearest_in_time_any_currency_t64(db, c, t):
    r"""gnc_pricedb_lookup_nearest_in_time_any_currency_t64(GNCPriceDB * db, gnc_commodity const * c, time64 t) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_nearest_in_time_any_currency_t64(db, c, t)

def gnc_pricedb_lookup_nearest_before_t64(db, c, currency, t):
    r"""gnc_pricedb_lookup_nearest_before_t64(GNCPriceDB * db, gnc_commodity const * c, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_nearest_before_t64(db, c, currency, t)

def gnc_pricedb_lookup_nearest_before_any_currency_t64(db, c, t):
    r"""gnc_pricedb_lookup_nearest_before_any_currency_t64(GNCPriceDB * db, gnc_commodity const * c, time64 t) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_nearest_before_any_currency_t64(db, c, t)

def gnc_pricedb_get_nearest_before_price(pdb, orig_currency, new_currency, t):
    r"""gnc_pricedb_get_nearest_before_price(GNCPriceDB * pdb, gnc_commodity const * orig_currency, gnc_commodity const * new_currency, time64 const t) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_get_nearest_before_price(pdb, orig_currency, new_currency, t)

def gnc_pricedb_get_nearest_price(pdb, orig_currency, new_currency, t):
    r"""gnc_pricedb_get_nearest_price(GNCPriceDB * pdb, gnc_commodity const * orig_currency, gnc_commodity const * new_currency, time64 const t) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_get_nearest_price(pdb, orig_currency, new_currency, t)

def gnc_pricedb_get_latest_price(pdb, orig_currency, new_currency):
    r"""gnc_pricedb_get_latest_price(GNCPriceDB * pdb, gnc_commodity const * orig_currency, gnc_commodity const * new_currency) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_get_latest_price(pdb, orig_currency, new_currency)

def gnc_pricedb_convert_balance_latest_price(pdb, balance, balance_currency, new_currency):
    r"""gnc_pricedb_convert_balance_latest_price(GNCPriceDB * pdb, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_convert_balance_latest_price(pdb, balance, balance_currency, new_currency)

def gnc_pricedb_convert_balance_nearest_price_t64(pdb, balance, balance_currency, new_currency, t):
    r"""gnc_pricedb_convert_balance_nearest_price_t64(GNCPriceDB * pdb, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency, time64 t) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_convert_balance_nearest_price_t64(pdb, balance, balance_currency, new_currency, t)

def gnc_pricedb_convert_balance_nearest_before_price_t64(pdb, balance, balance_currency, new_currency, t):
    r"""gnc_pricedb_convert_balance_nearest_before_price_t64(GNCPriceDB * pdb, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency, time64 t) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_convert_balance_nearest_before_price_t64(pdb, balance, balance_currency, new_currency, t)

def gnc_pricedb_foreach_price(db, f, user_data, stable_order):
    r"""gnc_pricedb_foreach_price(GNCPriceDB * db, GncPriceForeachFunc f, gpointer user_data, gboolean stable_order) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_foreach_price(db, f, user_data, stable_order)

def gnc_pricedb_num_prices(db, c):
    r"""gnc_pricedb_num_prices(GNCPriceDB * db, gnc_commodity const * c) -> int"""
    return _gnucash_core_c.gnc_pricedb_num_prices(db, c)

def gnc_pricedb_nth_price(db, c, n):
    r"""gnc_pricedb_nth_price(GNCPriceDB * db, gnc_commodity const * c, int const n) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_nth_price(db, c, n)

def gnc_pricedb_nth_price_reset_cache(db):
    r"""gnc_pricedb_nth_price_reset_cache(GNCPriceDB * db)"""
    return _gnucash_core_c.gnc_pricedb_nth_price_reset_cache(db)

def gnc_pricedb_get_num_prices(db):
    r"""gnc_pricedb_get_num_prices(GNCPriceDB * db) -> guint"""
    return _gnucash_core_c.gnc_pricedb_get_num_prices(db)

def gnc_pricedb_equal(db1, db2):
    r"""gnc_pricedb_equal(GNCPriceDB * db1, GNCPriceDB * db2) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_equal(db1, db2)

def gnc_pricedb_print_contents(db, f):
    r"""gnc_pricedb_print_contents(GNCPriceDB * db, FILE * f)"""
    return _gnucash_core_c.gnc_pricedb_print_contents(db, f)
PRICE_COMMODITY = _gnucash_core_c.PRICE_COMMODITY

PRICE_CURRENCY = _gnucash_core_c.PRICE_CURRENCY

PRICE_DATE = _gnucash_core_c.PRICE_DATE

PRICE_SOURCE = _gnucash_core_c.PRICE_SOURCE

PRICE_TYPE = _gnucash_core_c.PRICE_TYPE

PRICE_VALUE = _gnucash_core_c.PRICE_VALUE


def xaccSplitGetCapGains(arg1):
    r"""xaccSplitGetCapGains(Split * arg1) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetCapGains(arg1)

def xaccAccountHasTrades(arg1):
    r"""xaccAccountHasTrades(Account const * arg1) -> gboolean"""
    return _gnucash_core_c.xaccAccountHasTrades(arg1)

def xaccAccountFindEarliestOpenLot(acc, sign, currency):
    r"""xaccAccountFindEarliestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
    return _gnucash_core_c.xaccAccountFindEarliestOpenLot(acc, sign, currency)

def xaccAccountFindLatestOpenLot(acc, sign, currency):
    r"""xaccAccountFindLatestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
    return _gnucash_core_c.xaccAccountFindLatestOpenLot(acc, sign, currency)

def xaccSplitGetCapGainsSplit(arg1):
    r"""xaccSplitGetCapGainsSplit(Split const * arg1) -> Split *"""
    return _gnucash_core_c.xaccSplitGetCapGainsSplit(arg1)

def xaccSplitGetGainsSourceSplit(arg1):
    r"""xaccSplitGetGainsSourceSplit(Split const * arg1) -> Split *"""
    return _gnucash_core_c.xaccSplitGetGainsSourceSplit(arg1)

def xaccSplitAssign(split):
    r"""xaccSplitAssign(Split * split) -> gboolean"""
    return _gnucash_core_c.xaccSplitAssign(split)

def xaccSplitAssignToLot(split, lot):
    r"""xaccSplitAssignToLot(Split * split, GNCLot * lot) -> Split *"""
    return _gnucash_core_c.xaccSplitAssignToLot(split, lot)

def xaccSplitComputeCapGains(split, gain_acc):
    r"""xaccSplitComputeCapGains(Split * split, Account * gain_acc)"""
    return _gnucash_core_c.xaccSplitComputeCapGains(split, gain_acc)

def xaccLotComputeCapGains(lot, gain_acc):
    r"""xaccLotComputeCapGains(GNCLot * lot, Account * gain_acc)"""
    return _gnucash_core_c.xaccLotComputeCapGains(lot, gain_acc)

def xaccScrubLot(lot):
    r"""xaccScrubLot(GNCLot * lot) -> gboolean"""
    return _gnucash_core_c.xaccScrubLot(lot)

def xaccAccountScrubLots(acc):
    r"""xaccAccountScrubLots(Account * acc)"""
    return _gnucash_core_c.xaccAccountScrubLots(acc)

def xaccAccountTreeScrubLots(acc):
    r"""xaccAccountTreeScrubLots(Account * acc)"""
    return _gnucash_core_c.xaccAccountTreeScrubLots(acc)
QOF_MOD_ENGINE = _gnucash_core_c.QOF_MOD_ENGINE

QOF_LOG_FATAL = _gnucash_core_c.QOF_LOG_FATAL

QOF_LOG_ERROR = _gnucash_core_c.QOF_LOG_ERROR

QOF_LOG_WARNING = _gnucash_core_c.QOF_LOG_WARNING

QOF_LOG_MESSAGE = _gnucash_core_c.QOF_LOG_MESSAGE

QOF_LOG_INFO = _gnucash_core_c.QOF_LOG_INFO

QOF_LOG_DEBUG = _gnucash_core_c.QOF_LOG_DEBUG


def qof_log_level_to_string(lvl):
    r"""qof_log_level_to_string(QofLogLevel lvl) -> char const *"""
    return _gnucash_core_c.qof_log_level_to_string(lvl)

def qof_log_level_from_string(str):
    r"""qof_log_level_from_string(char const * str) -> QofLogLevel"""
    return _gnucash_core_c.qof_log_level_from_string(str)

def qof_log_indent():
    r"""qof_log_indent()"""
    return _gnucash_core_c.qof_log_indent()

def qof_log_dedent():
    r"""qof_log_dedent()"""
    return _gnucash_core_c.qof_log_dedent()

def qof_log_init():
    r"""qof_log_init()"""
    return _gnucash_core_c.qof_log_init()

def qof_log_set_level(module, level):
    r"""qof_log_set_level(QofLogModule module, QofLogLevel level)"""
    return _gnucash_core_c.qof_log_set_level(module, level)

def qof_log_set_file(outfile):
    r"""qof_log_set_file(FILE * outfile)"""
    return _gnucash_core_c.qof_log_set_file(outfile)

def qof_log_init_filename(logfilename):
    r"""qof_log_init_filename(gchar const * logfilename)"""
    return _gnucash_core_c.qof_log_init_filename(logfilename)

def qof_log_init_filename_special(log_to_filename):
    r"""qof_log_init_filename_special(char const * log_to_filename)"""
    return _gnucash_core_c.qof_log_init_filename_special(log_to_filename)

def qof_log_parse_log_config(filename):
    r"""qof_log_parse_log_config(char const * filename)"""
    return _gnucash_core_c.qof_log_parse_log_config(filename)

def qof_log_shutdown():
    r"""qof_log_shutdown()"""
    return _gnucash_core_c.qof_log_shutdown()

def qof_log_prettify(name):
    r"""qof_log_prettify(gchar const * name) -> gchar const *"""
    return _gnucash_core_c.qof_log_prettify(name)

def qof_log_check(log_module, log_level):
    r"""qof_log_check(QofLogModule log_module, QofLogLevel log_level) -> gboolean"""
    return _gnucash_core_c.qof_log_check(log_module, log_level)

def qof_book_new():
    r"""qof_book_new() -> QofBook *"""
    return _gnucash_core_c.qof_book_new()

