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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_gnucash_core_c')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_gnucash_core_c')
    _gnucash_core_c = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gnucash_core_c', [dirname(__file__)])
        except ImportError:
            import _gnucash_core_c
            return _gnucash_core_c
        try:
            _mod = imp.load_module('_gnucash_core_c', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _gnucash_core_c = swig_import_helper()
    del swig_import_helper
else:
    import _gnucash_core_c
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def gncSplitGetGUID(x: 'Split *') -> "GncGUID const *":
    """gncSplitGetGUID(Split * x) -> GncGUID"""
    return _gnucash_core_c.gncSplitGetGUID(x)

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

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

def gnc_split_get_type() -> "GType":
    """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: 'Split const *', account: 'Account const *') -> "gnc_numeric":
    """xaccSplitConvertAmount(Split const * split, Account const * account) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitConvertAmount(split, account)

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

def xaccSplitReinit(split: 'Split *') -> "void":
    """xaccSplitReinit(Split * split)"""
    return _gnucash_core_c.xaccSplitReinit(split)

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

def xaccSplitCopyOnto(from_split: 'Split const *', to_split: 'Split *') -> "void":
    """xaccSplitCopyOnto(Split const * from_split, Split * to_split)"""
    return _gnucash_core_c.xaccSplitCopyOnto(from_split, to_split)

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

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

def xaccSplitSetAccount(s: 'Split *', acc: 'Account *') -> "void":
    """xaccSplitSetAccount(Split * s, Account * acc)"""
    return _gnucash_core_c.xaccSplitSetAccount(s, acc)

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

def xaccSplitSetParent(split: 'Split *', trans: 'Transaction *') -> "void":
    """xaccSplitSetParent(Split * split, Transaction * trans)"""
    return _gnucash_core_c.xaccSplitSetParent(split, trans)

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

def xaccSplitSetLot(split: 'Split *', lot: 'GNCLot *') -> "void":
    """xaccSplitSetLot(Split * split, GNCLot * lot)"""
    return _gnucash_core_c.xaccSplitSetLot(split, lot)

def xaccSplitSetMemo(split: 'Split *', memo: 'char const *') -> "void":
    """xaccSplitSetMemo(Split * split, char const * memo)"""
    return _gnucash_core_c.xaccSplitSetMemo(split, memo)

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

def xaccSplitSetAction(split: 'Split *', action: 'char const *') -> "void":
    """xaccSplitSetAction(Split * split, char const * action)"""
    return _gnucash_core_c.xaccSplitSetAction(split, action)

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

def xaccSplitSetReconcile(split: 'Split *', reconciled_flag: 'char') -> "void":
    """xaccSplitSetReconcile(Split * split, char reconciled_flag)"""
    return _gnucash_core_c.xaccSplitSetReconcile(split, reconciled_flag)

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

def xaccSplitSetDateReconciledSecs(split: 'Split *', time: 'time64') -> "void":
    """xaccSplitSetDateReconciledSecs(Split * split, time64 time)"""
    return _gnucash_core_c.xaccSplitSetDateReconciledSecs(split, time)

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

def xaccSplitSetAmount(split: 'Split *', amount: '_gnc_numeric') -> "void":
    """xaccSplitSetAmount(Split * split, _gnc_numeric amount)"""
    return _gnucash_core_c.xaccSplitSetAmount(split, amount)

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

def xaccSplitSetValue(split: 'Split *', value: '_gnc_numeric') -> "void":
    """xaccSplitSetValue(Split * split, _gnc_numeric value)"""
    return _gnucash_core_c.xaccSplitSetValue(split, value)

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

def xaccSplitSetSharePriceAndAmount(split: 'Split *', price: '_gnc_numeric', amount: '_gnc_numeric') -> "void":
    """xaccSplitSetSharePriceAndAmount(Split * split, _gnc_numeric price, _gnc_numeric amount)"""
    return _gnucash_core_c.xaccSplitSetSharePriceAndAmount(split, price, amount)

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

def xaccSplitSetBaseValue(split: 'Split *', value: '_gnc_numeric', base_currency: 'gnc_commodity const *') -> "void":
    """xaccSplitSetBaseValue(Split * split, _gnc_numeric value, gnc_commodity const * base_currency)"""
    return _gnucash_core_c.xaccSplitSetBaseValue(split, value, base_currency)

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

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

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

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

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

def xaccSplitEqual(sa: 'Split const *', sb: 'Split const *', check_guids: 'gboolean', check_balances: 'gboolean', check_txn_splits: 'gboolean') -> "gboolean":
    """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: 'GncGUID', book: 'QofBook *') -> "Split *":
    """xaccSplitLookup(GncGUID guid, QofBook * book) -> Split *"""
    return _gnucash_core_c.xaccSplitLookup(guid, book)

def xaccSplitListGetUniqueTransactions(splits: 'GList const *') -> "GList *":
    """xaccSplitListGetUniqueTransactions(GList const * splits) -> GList *"""
    return _gnucash_core_c.xaccSplitListGetUniqueTransactions(splits)

def xaccSplitAddPeerSplit(split: 'Split *', other_split: 'Split const *', timestamp: 'time64 const') -> "void":
    """xaccSplitAddPeerSplit(Split * split, Split const * other_split, time64 const timestamp)"""
    return _gnucash_core_c.xaccSplitAddPeerSplit(split, other_split, timestamp)

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

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

def xaccSplitRemovePeerSplit(split: 'Split *', other_split: 'Split const *') -> "void":
    """xaccSplitRemovePeerSplit(Split * split, Split const * other_split)"""
    return _gnucash_core_c.xaccSplitRemovePeerSplit(split, other_split)

def xaccSplitMergePeerSplits(split: 'Split *', other_split: 'Split const *') -> "void":
    """xaccSplitMergePeerSplits(Split * split, Split const * other_split)"""
    return _gnucash_core_c.xaccSplitMergePeerSplits(split, other_split)

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

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

def xaccSplitMakeStockSplit(s: 'Split *') -> "void":
    """xaccSplitMakeStockSplit(Split * s)"""
    return _gnucash_core_c.xaccSplitMakeStockSplit(s)

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

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

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

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

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

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

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

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

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

def xaccSplitSetSharePrice(split: 'Split *', price: '_gnc_numeric') -> "void":
    """xaccSplitSetSharePrice(Split * split, _gnc_numeric price)"""
    return _gnucash_core_c.xaccSplitSetSharePrice(split, price)

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

def xaccSplitVoidFormerValue(split: 'Split const *') -> "gnc_numeric":
    """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: 'Account const *') -> "AccountList *":
    """gnc_account_get_children(Account const * account) -> AccountList *"""
    return _gnucash_core_c.gnc_account_get_children(account)

def gnc_account_get_children_sorted(account: 'Account const *') -> "AccountList *":
    """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: 'Account const *') -> "AccountList *":
    """gnc_account_get_descendants(Account const * account) -> AccountList *"""
    return _gnucash_core_c.gnc_account_get_descendants(account)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AccountClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AccountClass, name)
    __repr__ = _swig_repr
    __swig_setmethods__["parent_class"] = _gnucash_core_c.AccountClass_parent_class_set
    __swig_getmethods__["parent_class"] = _gnucash_core_c.AccountClass_parent_class_get
    if _newclass:
        parent_class = _swig_property(_gnucash_core_c.AccountClass_parent_class_get, _gnucash_core_c.AccountClass_parent_class_set)

    def __init__(self):
        """__init__(AccountClass self) -> AccountClass"""
        this = _gnucash_core_c.new_AccountClass()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_AccountClass
    __del__ = lambda self: None
AccountClass_swigregister = _gnucash_core_c.AccountClass_swigregister
AccountClass_swigregister(AccountClass)

class GncImportMatchMap(_object):
    """Proxy of C GncImportMatchMap struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GncImportMatchMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GncImportMatchMap, name)
    __repr__ = _swig_repr
    __swig_setmethods__["acc"] = _gnucash_core_c.GncImportMatchMap_acc_set
    __swig_getmethods__["acc"] = _gnucash_core_c.GncImportMatchMap_acc_get
    if _newclass:
        acc = _swig_property(_gnucash_core_c.GncImportMatchMap_acc_get, _gnucash_core_c.GncImportMatchMap_acc_set)
    __swig_setmethods__["book"] = _gnucash_core_c.GncImportMatchMap_book_set
    __swig_getmethods__["book"] = _gnucash_core_c.GncImportMatchMap_book_get
    if _newclass:
        book = _swig_property(_gnucash_core_c.GncImportMatchMap_book_get, _gnucash_core_c.GncImportMatchMap_book_set)

    def __init__(self):
        """__init__(GncImportMatchMap self) -> GncImportMatchMap"""
        this = _gnucash_core_c.new_GncImportMatchMap()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_GncImportMatchMap
    __del__ = lambda self: None
GncImportMatchMap_swigregister = _gnucash_core_c.GncImportMatchMap_swigregister
GncImportMatchMap_swigregister(GncImportMatchMap)


def gnc_account_get_type() -> "GType":
    """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: 'QofBook *') -> "Account *":
    """xaccMallocAccount(QofBook * book) -> Account *"""
    return _gnucash_core_c.xaccMallocAccount(book)

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

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

def xaccAccountBeginEdit(account: 'Account *') -> "void":
    """xaccAccountBeginEdit(Account * account)"""
    return _gnucash_core_c.xaccAccountBeginEdit(account)

def xaccAccountCommitEdit(account: 'Account *') -> "void":
    """xaccAccountCommitEdit(Account * account)"""
    return _gnucash_core_c.xaccAccountCommitEdit(account)

def xaccAccountDestroy(account: 'Account *') -> "void":
    """xaccAccountDestroy(Account * account)"""
    return _gnucash_core_c.xaccAccountDestroy(account)

def xaccAccountEqual(a: 'Account const *', b: 'Account const *', check_guids: 'gboolean') -> "gboolean":
    """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 const *', account_2: 'Account const *') -> "int":
    """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() -> "gchar const *":
    """gnc_get_account_separator_string() -> gchar const *"""
    return _gnucash_core_c.gnc_get_account_separator_string()

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

def gnc_set_account_separator(separator: 'gchar const *') -> "void":
    """gnc_set_account_separator(gchar const * separator)"""
    return _gnucash_core_c.gnc_set_account_separator(separator)

def gnc_book_get_root_account(book: 'QofBook *') -> "Account *":
    """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: 'QofBook *', root: 'Account *') -> "void":
    """gnc_book_set_root_account(QofBook * book, Account * root)"""
    return _gnucash_core_c.gnc_book_set_root_account(book, root)

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

def gnc_account_name_violations_errmsg(separator: 'gchar const *', invalid_account_names: 'GList *') -> "gchar *":
    """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: 'QofBook *', separator: 'gchar const *') -> "GList *":
    """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: 'Account const *') -> "QofBook *":
    """gnc_account_get_book(Account const * account) -> QofBook *"""
    return _gnucash_core_c.gnc_account_get_book(account)

def xaccAccountSetType(account: 'Account *', arg2: 'GNCAccountType') -> "void":
    """xaccAccountSetType(Account * account, GNCAccountType arg2)"""
    return _gnucash_core_c.xaccAccountSetType(account, arg2)

def xaccAccountSetName(account: 'Account *', name: 'char const *') -> "void":
    """xaccAccountSetName(Account * account, char const * name)"""
    return _gnucash_core_c.xaccAccountSetName(account, name)

def xaccAccountSetCode(account: 'Account *', code: 'char const *') -> "void":
    """xaccAccountSetCode(Account * account, char const * code)"""
    return _gnucash_core_c.xaccAccountSetCode(account, code)

def xaccAccountSetDescription(account: 'Account *', desc: 'char const *') -> "void":
    """xaccAccountSetDescription(Account * account, char const * desc)"""
    return _gnucash_core_c.xaccAccountSetDescription(account, desc)

def xaccAccountSetColor(account: 'Account *', color: 'char const *') -> "void":
    """xaccAccountSetColor(Account * account, char const * color)"""
    return _gnucash_core_c.xaccAccountSetColor(account, color)

def xaccAccountSetFilter(account: 'Account *', filter: 'char const *') -> "void":
    """xaccAccountSetFilter(Account * account, char const * filter)"""
    return _gnucash_core_c.xaccAccountSetFilter(account, filter)

def xaccAccountSetSortOrder(account: 'Account *', sortorder: 'char const *') -> "void":
    """xaccAccountSetSortOrder(Account * account, char const * sortorder)"""
    return _gnucash_core_c.xaccAccountSetSortOrder(account, sortorder)

def xaccAccountSetSortReversed(account: 'Account *', sortreversed: 'gboolean') -> "void":
    """xaccAccountSetSortReversed(Account * account, gboolean sortreversed)"""
    return _gnucash_core_c.xaccAccountSetSortReversed(account, sortreversed)

def xaccAccountSetNotes(account: 'Account *', notes: 'char const *') -> "void":
    """xaccAccountSetNotes(Account * account, char const * notes)"""
    return _gnucash_core_c.xaccAccountSetNotes(account, notes)

def xaccAccountSetLastNum(account: 'Account *', num: 'char const *') -> "void":
    """xaccAccountSetLastNum(Account * account, char const * num)"""
    return _gnucash_core_c.xaccAccountSetLastNum(account, num)

def gnc_account_set_policy(account: 'Account *', policy: 'GNCPolicy *') -> "void":
    """gnc_account_set_policy(Account * account, GNCPolicy * policy)"""
    return _gnucash_core_c.gnc_account_set_policy(account, policy)

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

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

def gnc_account_set_start_balance(acc: 'Account *', start_baln: '_gnc_numeric') -> "void":
    """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: 'Account *', start_baln: '_gnc_numeric') -> "void":
    """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: 'Account *', start_baln: '_gnc_numeric') -> "void":
    """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: 'Account *') -> "void":
    """gnc_account_set_balance_dirty(Account * acc)"""
    return _gnucash_core_c.gnc_account_set_balance_dirty(acc)

def gnc_account_set_sort_dirty(acc: 'Account *') -> "void":
    """gnc_account_set_sort_dirty(Account * acc)"""
    return _gnucash_core_c.gnc_account_set_sort_dirty(acc)

def gnc_account_insert_split(acc: 'Account *', s: 'Split *') -> "gboolean":
    """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: 'Account *', s: 'Split *') -> "gboolean":
    """gnc_account_remove_split(Account * acc, Split * s) -> gboolean"""
    return _gnucash_core_c.gnc_account_remove_split(acc, s)

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

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

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

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

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

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

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

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

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

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

def xaccAccountRecomputeBalance(arg1: 'Account *') -> "void":
    """xaccAccountRecomputeBalance(Account * arg1)"""
    return _gnucash_core_c.xaccAccountRecomputeBalance(arg1)

def xaccAccountSortSplits(acc: 'Account *', force: 'gboolean') -> "void":
    """xaccAccountSortSplits(Account * acc, gboolean force)"""
    return _gnucash_core_c.xaccAccountSortSplits(acc, force)

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

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

def dxaccAccountSetPriceSrc(account: 'Account *', src: 'char const *') -> "void":
    """dxaccAccountSetPriceSrc(Account * account, char const * src)"""
    return _gnucash_core_c.dxaccAccountSetPriceSrc(account, src)

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

def xaccAccountGetAutoInterestXfer(account: 'Account const *', default_value: 'gboolean') -> "gboolean":
    """xaccAccountGetAutoInterestXfer(Account const * account, gboolean default_value) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetAutoInterestXfer(account, default_value)

def xaccAccountSetAutoInterestXfer(account: 'Account *', value: 'gboolean') -> "void":
    """xaccAccountSetAutoInterestXfer(Account * account, gboolean value)"""
    return _gnucash_core_c.xaccAccountSetAutoInterestXfer(account, value)

def xaccAccountSetCommodity(account: 'Account *', comm: 'gnc_commodity *') -> "void":
    """xaccAccountSetCommodity(Account * account, gnc_commodity * comm)"""
    return _gnucash_core_c.xaccAccountSetCommodity(account, comm)

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

def gnc_account_get_currency_or_parent(account: 'Account const *') -> "gnc_commodity *":
    """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: 'Account const *') -> "int":
    """xaccAccountGetCommoditySCU(Account const * account) -> int"""
    return _gnucash_core_c.xaccAccountGetCommoditySCU(account)

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

def xaccAccountSetCommoditySCU(account: 'Account *', frac: 'int') -> "void":
    """xaccAccountSetCommoditySCU(Account * account, int frac)"""
    return _gnucash_core_c.xaccAccountSetCommoditySCU(account, frac)

def xaccAccountSetNonStdSCU(account: 'Account *', flag: 'gboolean') -> "void":
    """xaccAccountSetNonStdSCU(Account * account, gboolean flag)"""
    return _gnucash_core_c.xaccAccountSetNonStdSCU(account, flag)

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

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

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

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

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

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

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

def xaccAccountConvertBalanceToCurrency(account: 'Account const *', balance: '_gnc_numeric', balance_currency: 'gnc_commodity const *', new_currency: 'gnc_commodity const *') -> "gnc_numeric":
    """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: 'Account const *', balance: '_gnc_numeric', balance_currency: 'gnc_commodity *', new_currency: 'gnc_commodity *', date: 'time64') -> "gnc_numeric":
    """xaccAccountConvertBalanceToCurrencyAsOfDate(Account const * account, _gnc_numeric balance, gnc_commodity * balance_currency, gnc_commodity * new_currency, time64 date) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountConvertBalanceToCurrencyAsOfDate(account, balance, balance_currency, new_currency, date)

def xaccAccountGetBalanceInCurrency(account: 'Account const *', report_commodity: 'gnc_commodity const *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account const *', report_commodity: 'gnc_commodity const *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account const *', report_commodity: 'gnc_commodity const *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account const *', report_commodity: 'gnc_commodity const *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account const *', report_commodity: 'gnc_commodity const *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account *', date: 'time64', report_commodity: 'gnc_commodity *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account *', date: 'time64', report_commodity: 'gnc_commodity *', include_children: 'gboolean') -> "gnc_numeric":
    """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: 'Account *', date1: 'time64', date2: 'time64', recurse: 'gboolean') -> "gnc_numeric":
    """xaccAccountGetNoclosingBalanceChangeForPeriod(Account * acc, time64 date1, time64 date2, gboolean recurse) -> _gnc_numeric"""
    return _gnucash_core_c.xaccAccountGetNoclosingBalanceChangeForPeriod(acc, date1, date2, recurse)

def xaccAccountGetBalanceChangeForPeriod(acc: 'Account *', date1: 'time64', date2: 'time64', recurse: 'gboolean') -> "gnc_numeric":
    """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: 'Account *', child: 'Account *') -> "void":
    """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: 'Account *', child: 'Account *') -> "void":
    """gnc_account_remove_child(Account * parent, Account * child)"""
    return _gnucash_core_c.gnc_account_remove_child(parent, child)

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

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

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

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

def gnc_account_child_index(parent: 'Account const *', child: 'Account const *') -> "gint":
    """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: 'Account const *', num: 'gint') -> "Account *":
    """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: 'Account const *') -> "gint":
    """gnc_account_n_descendants(Account const * account) -> gint"""
    return _gnucash_core_c.gnc_account_n_descendants(account)

def gnc_account_get_current_depth(account: 'Account const *') -> "gint":
    """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: 'Account const *') -> "gint":
    """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: 'Account const *', func: 'AccountCb', user_data: 'gpointer') -> "void":
    """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: 'Account const *', func: 'AccountCb', user_data: 'gpointer') -> "void":
    """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: 'Account const *', func: 'AccountCb2', user_data: 'gpointer') -> "gpointer":
    """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: 'Account *', from_parent: 'Account *') -> "void":
    """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: 'Account *') -> "void":
    """gnc_account_merge_children(Account * parent)"""
    return _gnucash_core_c.gnc_account_merge_children(parent)

def xaccAccountSetReconcileChildrenStatus(account: 'Account *', status: 'gboolean') -> "void":
    """xaccAccountSetReconcileChildrenStatus(Account * account, gboolean status)"""
    return _gnucash_core_c.xaccAccountSetReconcileChildrenStatus(account, status)

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

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

def gnc_account_lookup_by_name(parent: 'Account const *', name: 'char const *') -> "Account *":
    """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: 'Account const *', name: 'gchar const *') -> "Account *":
    """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: 'Account const *', code: 'char const *') -> "Account *":
    """gnc_account_lookup_by_code(Account const * parent, char const * code) -> Account *"""
    return _gnucash_core_c.gnc_account_lookup_by_code(parent, code)

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

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

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

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

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

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

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

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

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

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

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

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

def xaccAccountCountSplits(acc: 'Account const *', include_children: 'gboolean') -> "gint64":
    """xaccAccountCountSplits(Account const * acc, gboolean include_children) -> gint64"""
    return _gnucash_core_c.xaccAccountCountSplits(acc, include_children)

def xaccAccountMoveAllSplits(accfrom: 'Account *', accto: 'Account *') -> "void":
    """xaccAccountMoveAllSplits(Account * accfrom, Account * accto)"""
    return _gnucash_core_c.xaccAccountMoveAllSplits(accfrom, accto)

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

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

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

def xaccAccountInsertLot(arg1: 'Account *', arg2: 'GNCLot *') -> "void":
    """xaccAccountInsertLot(Account * arg1, GNCLot * arg2)"""
    return _gnucash_core_c.xaccAccountInsertLot(arg1, arg2)

def xaccAccountRemoveLot(arg1: 'Account *', arg2: 'GNCLot *') -> "void":
    """xaccAccountRemoveLot(Account * arg1, GNCLot * arg2)"""
    return _gnucash_core_c.xaccAccountRemoveLot(arg1, arg2)

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

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

def xaccAccountFindOpenLots(acc: 'Account const *', match_func: 'gboolean (*)(GNCLot *,gpointer)', user_data: 'gpointer', sort_func: 'GCompareFunc') -> "LotList *":
    """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: 'Account const *') -> "time64 *":
    """xaccAccountGetReconcileLastDate(Account const * account) -> gboolean"""
    return _gnucash_core_c.xaccAccountGetReconcileLastDate(account)

def xaccAccountSetReconcileLastDate(account: 'Account *', last_date: 'time64') -> "void":
    """xaccAccountSetReconcileLastDate(Account * account, time64 last_date)"""
    return _gnucash_core_c.xaccAccountSetReconcileLastDate(account, last_date)

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

def xaccAccountSetReconcileLastInterval(account: 'Account *', months: 'int', days: 'int') -> "void":
    """xaccAccountSetReconcileLastInterval(Account * account, int months, int days)"""
    return _gnucash_core_c.xaccAccountSetReconcileLastInterval(account, months, days)

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

def xaccAccountSetReconcilePostponeDate(account: 'Account *', postpone_date: 'time64') -> "void":
    """xaccAccountSetReconcilePostponeDate(Account * account, time64 postpone_date)"""
    return _gnucash_core_c.xaccAccountSetReconcilePostponeDate(account, postpone_date)

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

def xaccAccountSetReconcilePostponeBalance(account: 'Account *', balance: '_gnc_numeric') -> "void":
    """xaccAccountSetReconcilePostponeBalance(Account * account, _gnc_numeric balance)"""
    return _gnucash_core_c.xaccAccountSetReconcilePostponeBalance(account, balance)

def xaccAccountClearReconcilePostpone(account: 'Account *') -> "void":
    """xaccAccountClearReconcilePostpone(Account * account)"""
    return _gnucash_core_c.xaccAccountClearReconcilePostpone(account)
PLACEHOLDER_NONE = _gnucash_core_c.PLACEHOLDER_NONE
PLACEHOLDER_THIS = _gnucash_core_c.PLACEHOLDER_THIS
PLACEHOLDER_CHILD = _gnucash_core_c.PLACEHOLDER_CHILD

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

def xaccAccountSetPlaceholder(account: 'Account *', val: 'gboolean') -> "void":
    """xaccAccountSetPlaceholder(Account * account, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetPlaceholder(account, val)

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

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

def xaccAccountSetHidden(acc: 'Account *', val: 'gboolean') -> "void":
    """xaccAccountSetHidden(Account * acc, gboolean val)"""
    return _gnucash_core_c.xaccAccountSetHidden(acc, val)

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

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

def xaccAccountSetTaxRelated(account: 'Account *', tax_related: 'gboolean') -> "void":
    """xaccAccountSetTaxRelated(Account * account, gboolean tax_related)"""
    return _gnucash_core_c.xaccAccountSetTaxRelated(account, tax_related)

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

def xaccAccountSetTaxUSCode(account: 'Account *', code: 'char const *') -> "void":
    """xaccAccountSetTaxUSCode(Account * account, char const * code)"""
    return _gnucash_core_c.xaccAccountSetTaxUSCode(account, code)

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

def xaccAccountSetTaxUSPayerNameSource(account: 'Account *', source: 'char const *') -> "void":
    """xaccAccountSetTaxUSPayerNameSource(Account * account, char const * source)"""
    return _gnucash_core_c.xaccAccountSetTaxUSPayerNameSource(account, source)

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

def xaccAccountSetTaxUSCopyNumber(account: 'Account *', copy_number: 'gint64') -> "void":
    """xaccAccountSetTaxUSCopyNumber(Account * account, gint64 copy_number)"""
    return _gnucash_core_c.xaccAccountSetTaxUSCopyNumber(account, copy_number)

def xaccAccountSetMark(account: 'Account *', mark: 'short') -> "void":
    """xaccAccountSetMark(Account * account, short mark)"""
    return _gnucash_core_c.xaccAccountSetMark(account, mark)

def xaccClearMark(account: 'Account *', val: 'short') -> "void":
    """xaccClearMark(Account * account, short val)"""
    return _gnucash_core_c.xaccClearMark(account, val)

def xaccClearMarkDown(account: 'Account *', val: 'short') -> "void":
    """xaccClearMarkDown(Account * account, short val)"""
    return _gnucash_core_c.xaccClearMarkDown(account, val)

def gnc_account_tree_begin_staged_transaction_traversals(acc: 'Account *') -> "void":
    """gnc_account_tree_begin_staged_transaction_traversals(Account * acc)"""
    return _gnucash_core_c.gnc_account_tree_begin_staged_transaction_traversals(acc)

def xaccSplitsBeginStagedTransactionTraversals(splits: 'SplitList *') -> "void":
    """xaccSplitsBeginStagedTransactionTraversals(SplitList * splits)"""
    return _gnucash_core_c.xaccSplitsBeginStagedTransactionTraversals(splits)

def xaccAccountBeginStagedTransactionTraversals(account: 'Account const *') -> "void":
    """xaccAccountBeginStagedTransactionTraversals(Account const * account)"""
    return _gnucash_core_c.xaccAccountBeginStagedTransactionTraversals(account)

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

def xaccAccountStagedTransactionTraversal(a: 'Account const *', stage: 'unsigned int', thunk: 'TransactionCallback', data: 'void *') -> "int":
    """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: 'Account const *', stage: 'unsigned int', thunk: 'TransactionCallback', data: 'void *') -> "int":
    """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: 'Account *', proc: 'TransactionCallback', data: 'void *') -> "int":
    """xaccAccountTreeForEachTransaction(Account * acc, TransactionCallback proc, void * data) -> int"""
    return _gnucash_core_c.xaccAccountTreeForEachTransaction(acc, proc, data)

def gnc_account_imap_create_imap(acc: 'Account *') -> "GncImportMatchMap *":
    """gnc_account_imap_create_imap(Account * acc) -> GncImportMatchMap"""
    return _gnucash_core_c.gnc_account_imap_create_imap(acc)

def gnc_account_imap_find_account(imap: 'GncImportMatchMap', category: 'char const *', key: 'char const *') -> "Account *":
    """gnc_account_imap_find_account(GncImportMatchMap imap, char const * category, char const * key) -> Account *"""
    return _gnucash_core_c.gnc_account_imap_find_account(imap, category, key)

def gnc_account_imap_add_account(imap: 'GncImportMatchMap', category: 'char const *', key: 'char const *', acc: 'Account *') -> "void":
    """gnc_account_imap_add_account(GncImportMatchMap imap, char const * category, char const * key, Account * acc)"""
    return _gnucash_core_c.gnc_account_imap_add_account(imap, category, key, acc)

def gnc_account_imap_delete_account(imap: 'GncImportMatchMap', category: 'char const *', key: 'char const *') -> "void":
    """gnc_account_imap_delete_account(GncImportMatchMap imap, char const * category, char const * key)"""
    return _gnucash_core_c.gnc_account_imap_delete_account(imap, category, key)

def gnc_account_imap_find_account_bayes(imap: 'GncImportMatchMap', tokens: 'GList *') -> "Account *":
    """gnc_account_imap_find_account_bayes(GncImportMatchMap imap, GList * tokens) -> Account *"""
    return _gnucash_core_c.gnc_account_imap_find_account_bayes(imap, tokens)

def gnc_account_imap_add_account_bayes(imap: 'GncImportMatchMap', tokens: 'GList *', acc: 'Account *') -> "void":
    """gnc_account_imap_add_account_bayes(GncImportMatchMap imap, GList * tokens, Account * acc)"""
    return _gnucash_core_c.gnc_account_imap_add_account_bayes(imap, tokens, acc)
class GncImapInfo(_object):
    """Proxy of C imap_info struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GncImapInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GncImapInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["source_account"] = _gnucash_core_c.GncImapInfo_source_account_set
    __swig_getmethods__["source_account"] = _gnucash_core_c.GncImapInfo_source_account_get
    if _newclass:
        source_account = _swig_property(_gnucash_core_c.GncImapInfo_source_account_get, _gnucash_core_c.GncImapInfo_source_account_set)
    __swig_setmethods__["map_account"] = _gnucash_core_c.GncImapInfo_map_account_set
    __swig_getmethods__["map_account"] = _gnucash_core_c.GncImapInfo_map_account_get
    if _newclass:
        map_account = _swig_property(_gnucash_core_c.GncImapInfo_map_account_get, _gnucash_core_c.GncImapInfo_map_account_set)
    __swig_setmethods__["list"] = _gnucash_core_c.GncImapInfo_list_set
    __swig_getmethods__["list"] = _gnucash_core_c.GncImapInfo_list_get
    if _newclass:
        list = _swig_property(_gnucash_core_c.GncImapInfo_list_get, _gnucash_core_c.GncImapInfo_list_set)
    __swig_setmethods__["head"] = _gnucash_core_c.GncImapInfo_head_set
    __swig_getmethods__["head"] = _gnucash_core_c.GncImapInfo_head_get
    if _newclass:
        head = _swig_property(_gnucash_core_c.GncImapInfo_head_get, _gnucash_core_c.GncImapInfo_head_set)
    __swig_setmethods__["category"] = _gnucash_core_c.GncImapInfo_category_set
    __swig_getmethods__["category"] = _gnucash_core_c.GncImapInfo_category_get
    if _newclass:
        category = _swig_property(_gnucash_core_c.GncImapInfo_category_get, _gnucash_core_c.GncImapInfo_category_set)
    __swig_setmethods__["match_string"] = _gnucash_core_c.GncImapInfo_match_string_set
    __swig_getmethods__["match_string"] = _gnucash_core_c.GncImapInfo_match_string_get
    if _newclass:
        match_string = _swig_property(_gnucash_core_c.GncImapInfo_match_string_get, _gnucash_core_c.GncImapInfo_match_string_set)
    __swig_setmethods__["count"] = _gnucash_core_c.GncImapInfo_count_set
    __swig_getmethods__["count"] = _gnucash_core_c.GncImapInfo_count_get
    if _newclass:
        count = _swig_property(_gnucash_core_c.GncImapInfo_count_get, _gnucash_core_c.GncImapInfo_count_set)

    def __init__(self):
        """__init__(imap_info self) -> GncImapInfo"""
        this = _gnucash_core_c.new_GncImapInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_GncImapInfo
    __del__ = lambda self: None
GncImapInfo_swigregister = _gnucash_core_c.GncImapInfo_swigregister
GncImapInfo_swigregister(GncImapInfo)


def gnc_account_imap_get_info_bayes(acc: 'Account *') -> "GList *":
    """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: 'Account *', category: 'char const *') -> "GList *":
    """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: 'Account *', full_category: 'char const *') -> "gchar *":
    """gnc_account_get_map_entry(Account * acc, char const * full_category) -> gchar *"""
    return _gnucash_core_c.gnc_account_get_map_entry(acc, full_category)

def gnc_account_delete_map_entry(acc: 'Account *', head: 'char *', category: 'char *', match_string: 'char *', empty: 'gboolean') -> "void":
    """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: 'Account *') -> "void":
    """gnc_account_delete_all_bayes_maps(Account * acc)"""
    return _gnucash_core_c.gnc_account_delete_all_bayes_maps(acc)

def DxaccAccountSetCurrency(account: 'Account *', currency: 'gnc_commodity *') -> "void":
    """DxaccAccountSetCurrency(Account * account, gnc_commodity * currency)"""
    return _gnucash_core_c.DxaccAccountSetCurrency(account, currency)

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

def dxaccAccountSetQuoteTZ(account: 'Account *', tz: 'char const *') -> "void":
    """dxaccAccountSetQuoteTZ(Account * account, char const * tz)"""
    return _gnucash_core_c.dxaccAccountSetQuoteTZ(account, tz)

def dxaccAccountGetQuoteTZ(account: 'Account const *') -> "char const *":
    """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_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() -> "GType":
    """gnc_transaction_get_type() -> GType"""
    return _gnucash_core_c.gnc_transaction_get_type()
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: 'QofBook *') -> "Transaction *":
    """xaccMallocTransaction(QofBook * book) -> Transaction *"""
    return _gnucash_core_c.xaccMallocTransaction(book)

def xaccTransDestroy(trans: 'Transaction *') -> "void":
    """xaccTransDestroy(Transaction * trans)"""
    return _gnucash_core_c.xaccTransDestroy(trans)

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

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

def xaccTransEqual(ta: 'Transaction const *', tb: 'Transaction const *', check_guids: 'gboolean', check_splits: 'gboolean', check_balances: 'gboolean', assume_ordered: 'gboolean') -> "gboolean":
    """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: 'Transaction *') -> "void":
    """xaccTransBeginEdit(Transaction * trans)"""
    return _gnucash_core_c.xaccTransBeginEdit(trans)

def xaccTransCommitEdit(trans: 'Transaction *') -> "void":
    """xaccTransCommitEdit(Transaction * trans)"""
    return _gnucash_core_c.xaccTransCommitEdit(trans)

def xaccTransRollbackEdit(trans: 'Transaction *') -> "void":
    """xaccTransRollbackEdit(Transaction * trans)"""
    return _gnucash_core_c.xaccTransRollbackEdit(trans)

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

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

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

def xaccTransCopyOnto(from_trans: 'Transaction const *', to_trans: 'Transaction *') -> "void":
    """xaccTransCopyOnto(Transaction const * from_trans, Transaction * to_trans)"""
    return _gnucash_core_c.xaccTransCopyOnto(from_trans, to_trans)

def xaccTransCopyFromClipBoard(from_trans: 'Transaction const *', to_trans: 'Transaction *', from_acc: 'Account const *', to_acc: 'Account *', no_date: 'gboolean') -> "void":
    """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: 'Transaction const *', acc: 'Account const *') -> "Split *":
    """xaccTransFindSplitByAccount(Transaction const * trans, Account const * acc) -> Split *"""
    return _gnucash_core_c.xaccTransFindSplitByAccount(trans, acc)

def xaccTransScrubGains(trans: 'Transaction *', gain_acc: 'Account *') -> "void":
    """xaccTransScrubGains(Transaction * trans, Account * gain_acc)"""
    return _gnucash_core_c.xaccTransScrubGains(trans, gain_acc)

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

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

def xaccTransSortSplits(trans: 'Transaction *') -> "void":
    """xaccTransSortSplits(Transaction * trans)"""
    return _gnucash_core_c.xaccTransSortSplits(trans)

def xaccTransSetTxnType(trans: 'Transaction *', type: 'char') -> "void":
    """xaccTransSetTxnType(Transaction * trans, char type)"""
    return _gnucash_core_c.xaccTransSetTxnType(trans, type)

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

def xaccTransSetNum(trans: 'Transaction *', num: 'char const *') -> "void":
    """xaccTransSetNum(Transaction * trans, char const * num)"""
    return _gnucash_core_c.xaccTransSetNum(trans, num)

def xaccTransSetDescription(trans: 'Transaction *', desc: 'char const *') -> "void":
    """xaccTransSetDescription(Transaction * trans, char const * desc)"""
    return _gnucash_core_c.xaccTransSetDescription(trans, desc)

def xaccTransSetAssociation(trans: 'Transaction *', assoc: 'char const *') -> "void":
    """xaccTransSetAssociation(Transaction * trans, char const * assoc)"""
    return _gnucash_core_c.xaccTransSetAssociation(trans, assoc)

def xaccTransSetNotes(trans: 'Transaction *', notes: 'char const *') -> "void":
    """xaccTransSetNotes(Transaction * trans, char const * notes)"""
    return _gnucash_core_c.xaccTransSetNotes(trans, notes)

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

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

def xaccTransGetAssociation(trans: 'Transaction const *') -> "char const *":
    """xaccTransGetAssociation(Transaction const * trans) -> char const *"""
    return _gnucash_core_c.xaccTransGetAssociation(trans)

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

def xaccTransSetIsClosingTxn(trans: 'Transaction *', is_closing: 'gboolean') -> "void":
    """xaccTransSetIsClosingTxn(Transaction * trans, gboolean is_closing)"""
    return _gnucash_core_c.xaccTransSetIsClosingTxn(trans, is_closing)

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

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

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

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

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

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

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

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

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

def xaccTransSetReadOnly(trans: 'Transaction *', reason: 'char const *') -> "void":
    """xaccTransSetReadOnly(Transaction * trans, char const * reason)"""
    return _gnucash_core_c.xaccTransSetReadOnly(trans, reason)

def xaccTransClearReadOnly(trans: 'Transaction *') -> "void":
    """xaccTransClearReadOnly(Transaction * trans)"""
    return _gnucash_core_c.xaccTransClearReadOnly(trans)

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

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

def xaccTransInFutureByPostedDate(trans: 'Transaction const *') -> "gboolean":
    """xaccTransInFutureByPostedDate(Transaction const * trans) -> gboolean"""
    return _gnucash_core_c.xaccTransInFutureByPostedDate(trans)

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

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

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

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

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

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

def xaccTransSetCurrency(trans: 'Transaction *', curr: 'gnc_commodity *') -> "void":
    """xaccTransSetCurrency(Transaction * trans, gnc_commodity * curr)"""
    return _gnucash_core_c.xaccTransSetCurrency(trans, curr)

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

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

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

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

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

def xaccTransGetRateForCommodity(trans: 'Transaction const *', split_com: 'gnc_commodity const *', split_to_exclude: 'Split const *', rate: '_gnc_numeric') -> "gboolean":
    """xaccTransGetRateForCommodity(Transaction const * trans, gnc_commodity const * split_com, Split const * split_to_exclude, _gnc_numeric rate) -> gboolean"""
    return _gnucash_core_c.xaccTransGetRateForCommodity(trans, split_com, split_to_exclude, rate)

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

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

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

def xaccTransOrder_num_action(ta: 'Transaction const *', actna: 'char const *', tb: 'Transaction const *', actnb: 'char const *') -> "int":
    """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: 'Transaction *', day: 'int', mon: 'int', year: 'int') -> "void":
    """xaccTransSetDate(Transaction * trans, int day, int mon, int year)"""
    return _gnucash_core_c.xaccTransSetDate(trans, day, mon, year)

def xaccTransSetDatePostedGDate(trans: 'Transaction *', date: 'GDate') -> "void":
    """xaccTransSetDatePostedGDate(Transaction * trans, GDate date)"""
    return _gnucash_core_c.xaccTransSetDatePostedGDate(trans, date)

def xaccTransSetDatePostedSecs(trans: 'Transaction *', time: 'time64') -> "void":
    """xaccTransSetDatePostedSecs(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDatePostedSecs(trans, time)

def xaccTransSetDatePostedSecsNormalized(trans: 'Transaction *', time: 'time64') -> "void":
    """xaccTransSetDatePostedSecsNormalized(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDatePostedSecsNormalized(trans, time)

def xaccTransSetDateEnteredSecs(trans: 'Transaction *', time: 'time64') -> "void":
    """xaccTransSetDateEnteredSecs(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDateEnteredSecs(trans, time)

def xaccTransSetDateDue(trans: 'Transaction *', time: 'time64') -> "void":
    """xaccTransSetDateDue(Transaction * trans, time64 time)"""
    return _gnucash_core_c.xaccTransSetDateDue(trans, time)

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

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

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

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

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

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

def xaccTransVoid(transaction: 'Transaction *', reason: 'char const *') -> "void":
    """xaccTransVoid(Transaction * transaction, char const * reason)"""
    return _gnucash_core_c.xaccTransVoid(transaction, reason)

def xaccTransUnvoid(transaction: 'Transaction *') -> "void":
    """xaccTransUnvoid(Transaction * transaction)"""
    return _gnucash_core_c.xaccTransUnvoid(transaction)

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

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

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

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

def xaccTransGetVoidTime(tr: 'Transaction const *') -> "time64":
    """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_ASSOCIATION = _gnucash_core_c.TRANS_ASSOCIATION
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
RECONCILED_MATCH_TYPE = _gnucash_core_c.RECONCILED_MATCH_TYPE
class GncLotClass(_object):
    """Proxy of C GncLotClass struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GncLotClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GncLotClass, name)
    __repr__ = _swig_repr
    __swig_setmethods__["parent_class"] = _gnucash_core_c.GncLotClass_parent_class_set
    __swig_getmethods__["parent_class"] = _gnucash_core_c.GncLotClass_parent_class_get
    if _newclass:
        parent_class = _swig_property(_gnucash_core_c.GncLotClass_parent_class_get, _gnucash_core_c.GncLotClass_parent_class_set)

    def __init__(self):
        """__init__(GncLotClass self) -> GncLotClass"""
        this = _gnucash_core_c.new_GncLotClass()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_GncLotClass
    __del__ = lambda self: None
GncLotClass_swigregister = _gnucash_core_c.GncLotClass_swigregister
GncLotClass_swigregister(GncLotClass)


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

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

def gnc_lot_destroy(arg1: 'GNCLot *') -> "void":
    """gnc_lot_destroy(GNCLot * arg1)"""
    return _gnucash_core_c.gnc_lot_destroy(arg1)

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

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

def gnc_lot_begin_edit(lot: 'GNCLot *') -> "void":
    """gnc_lot_begin_edit(GNCLot * lot)"""
    return _gnucash_core_c.gnc_lot_begin_edit(lot)

def gnc_lot_commit_edit(lot: 'GNCLot *') -> "void":
    """gnc_lot_commit_edit(GNCLot * lot)"""
    return _gnucash_core_c.gnc_lot_commit_edit(lot)

def gnc_lot_add_split(arg1: 'GNCLot *', arg2: 'Split *') -> "void":
    """gnc_lot_add_split(GNCLot * arg1, Split * arg2)"""
    return _gnucash_core_c.gnc_lot_add_split(arg1, arg2)

def gnc_lot_remove_split(arg1: 'GNCLot *', arg2: 'Split *') -> "void":
    """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: 'GNCLot const *') -> "SplitList *":
    """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: 'GNCLot const *') -> "gint":
    """gnc_lot_count_splits(GNCLot const * arg1) -> gint"""
    return _gnucash_core_c.gnc_lot_count_splits(arg1)

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

def gnc_lot_set_account(arg1: 'GNCLot *', arg2: 'Account *') -> "void":
    """gnc_lot_set_account(GNCLot * arg1, Account * arg2)"""
    return _gnucash_core_c.gnc_lot_set_account(arg1, arg2)

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

def gnc_lot_get_balance_before(arg1: 'GNCLot const *', arg2: 'Split const *', arg3: '_gnc_numeric', arg4: '_gnc_numeric') -> "void":
    """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: 'GNCLot *') -> "gboolean":
    """gnc_lot_is_closed(GNCLot * arg1) -> gboolean"""
    return _gnucash_core_c.gnc_lot_is_closed(arg1)

def gnc_lot_get_earliest_split(lot: 'GNCLot *') -> "Split *":
    """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: 'GNCLot *') -> "Split *":
    """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: 'GNCLot *') -> "void":
    """gnc_lot_set_closed_unknown(GNCLot * arg1)"""
    return _gnucash_core_c.gnc_lot_set_closed_unknown(arg1)

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

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

def gnc_lot_set_title(arg1: 'GNCLot *', arg2: 'char const *') -> "void":
    """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: 'GNCLot *', arg2: 'char const *') -> "void":
    """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: 'Account *') -> "GNCLot *":
    """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: 'QofBackend *') -> "QofBackendError":
    """qof_backend_get_error(QofBackend * arg1) -> QofBackendError"""
    return _gnucash_core_c.qof_backend_get_error(arg1)

def qof_backend_set_error(arg1: 'QofBackend *', arg2: 'QofBackendError') -> "void":
    """qof_backend_set_error(QofBackend * arg1, QofBackendError arg2)"""
    return _gnucash_core_c.qof_backend_set_error(arg1, arg2)

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

def qof_backend_rollback_instance(arg1: 'QofBackend *', arg2: 'QofInstance *') -> "void":
    """qof_backend_rollback_instance(QofBackend * arg1, QofInstance * arg2)"""
    return _gnucash_core_c.qof_backend_rollback_instance(arg1, arg2)

def qof_load_backend_library(directory: 'gchar const *', module_name: 'gchar const *') -> "gboolean":
    """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() -> "void":
    """qof_finalize_backend_libraries()"""
    return _gnucash_core_c.qof_finalize_backend_libraries()

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

def qof_book_set_backend(book: 'QofBook *', arg2: 'QofBackend *') -> "void":
    """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

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

def qof_session_destroy(session: 'QofSession *') -> "void":
    """qof_session_destroy(QofSession * session)"""
    return _gnucash_core_c.qof_session_destroy(session)

def qof_session_swap_data(session_1: 'QofSession *', session_2: 'QofSession *') -> "void":
    """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: 'QofSession *', book_id: 'char const *', ignore_lock: 'gboolean', create: 'gboolean', force: 'gboolean') -> "void":
    """qof_session_begin(QofSession * session, char const * book_id, gboolean ignore_lock, gboolean create, gboolean force)"""
    return _gnucash_core_c.qof_session_begin(session, book_id, ignore_lock, create, force)

def qof_session_load(session: 'QofSession *', percentage_func: 'QofPercentageFunc') -> "void":
    """qof_session_load(QofSession * session, QofPercentageFunc percentage_func)"""
    return _gnucash_core_c.qof_session_load(session, percentage_func)

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

def qof_session_get_error_message(session: 'QofSession const *') -> "char const *":
    """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: 'QofSession *') -> "QofBackendError":
    """qof_session_pop_error(QofSession * session) -> QofBackendError"""
    return _gnucash_core_c.qof_session_pop_error(session)

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

def qof_session_get_file_path(session: 'QofSession const *') -> "char const *":
    """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: 'QofSession const *') -> "char const *":
    """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: 'QofSession const *') -> "gboolean":
    """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: 'QofSession const *') -> "QofBackend *":
    """qof_session_get_backend(QofSession const * session) -> QofBackend *"""
    return _gnucash_core_c.qof_session_get_backend(session)

def qof_session_save(session: 'QofSession *', percentage_func: 'QofPercentageFunc') -> "void":
    """qof_session_save(QofSession * session, QofPercentageFunc percentage_func)"""
    return _gnucash_core_c.qof_session_save(session, percentage_func)

def qof_session_safe_save(session: 'QofSession *', percentage_func: 'QofPercentageFunc') -> "void":
    """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: 'QofSession *') -> "void":
    """qof_session_end(QofSession * session)"""
    return _gnucash_core_c.qof_session_end(session)
QOF_STDOUT = _gnucash_core_c.QOF_STDOUT

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

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

def qof_session_export(tmp_session: 'QofSession *', real_session: 'QofSession *', percentage_func: 'QofPercentageFunc') -> "gboolean":
    """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() -> "GList *":
    """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: 'QofSession *') -> "void":
    """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: 'QofBook const *') -> "gboolean":
    """qof_book_use_trading_accounts(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_use_trading_accounts(book)

def qof_book_get_book_currency_name(book: 'QofBook *') -> "gchar const *":
    """qof_book_get_book_currency_name(QofBook * book) -> gchar const *"""
    return _gnucash_core_c.qof_book_get_book_currency_name(book)

def qof_book_get_default_gains_policy(book: 'QofBook *') -> "gchar const *":
    """qof_book_get_default_gains_policy(QofBook * book) -> gchar const *"""
    return _gnucash_core_c.qof_book_get_default_gains_policy(book)

def qof_book_get_default_gain_loss_acct_guid(book: 'QofBook *') -> "GncGUID *":
    """qof_book_get_default_gain_loss_acct_guid(QofBook * book) -> GncGUID"""
    return _gnucash_core_c.qof_book_get_default_gain_loss_acct_guid(book)

def qof_book_uses_autoreadonly(book: 'QofBook const *') -> "gboolean":
    """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: 'QofBook const *') -> "gint":
    """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: 'QofBook const *') -> "GDate *":
    """qof_book_get_autoreadonly_gdate(QofBook const * book) -> GDate *"""
    return _gnucash_core_c.qof_book_get_autoreadonly_gdate(book)

def qof_book_use_split_action_for_num_field(book: 'QofBook const *') -> "gboolean":
    """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: 'QofBook const *') -> "gboolean":
    """qof_book_shutting_down(QofBook const * book) -> gboolean"""
    return _gnucash_core_c.qof_book_shutting_down(book)

def qof_book_session_not_saved(book: 'QofBook const *') -> "gboolean":
    """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: 'QofIdType') -> "QofCollection *":
    """qof_collection_new(QofIdType type) -> QofCollection *"""
    return _gnucash_core_c.qof_collection_new(type)

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

def qof_collection_destroy(col: 'QofCollection *') -> "void":
    """qof_collection_destroy(QofCollection * col)"""
    return _gnucash_core_c.qof_collection_destroy(col)

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

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

def qof_collection_foreach(arg1: 'QofCollection const *', arg2: 'QofInstanceForeachCB', user_data: 'gpointer') -> "void":
    """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: 'QofCollection const *') -> "gpointer":
    """qof_collection_get_data(QofCollection const * col) -> gpointer"""
    return _gnucash_core_c.qof_collection_get_data(col)

def qof_collection_set_data(col: 'QofCollection *', user_data: 'gpointer') -> "void":
    """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: 'QofCollection const *') -> "gboolean":
    """qof_collection_is_dirty(QofCollection const * col) -> gboolean"""
    return _gnucash_core_c.qof_collection_is_dirty(col)

def qof_collection_add_entity(coll: 'QofCollection *', ent: 'QofInstance *') -> "gboolean":
    """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: 'QofInstance *') -> "void":
    """qof_collection_remove_entity(QofInstance * ent)"""
    return _gnucash_core_c.qof_collection_remove_entity(ent)

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

def qof_collection_from_glist(type: 'QofIdType', glist: 'GList const *') -> "QofCollection *":
    """qof_collection_from_glist(QofIdType type, GList const * glist) -> QofCollection *"""
    return _gnucash_core_c.qof_collection_from_glist(type, glist)
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() -> "void":
    """qof_query_init()"""
    return _gnucash_core_c.qof_query_init()

def qof_query_shutdown() -> "void":
    """qof_query_shutdown()"""
    return _gnucash_core_c.qof_query_shutdown()

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

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

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

def qof_query_destroy(q: 'QofQuery *') -> "void":
    """qof_query_destroy(QofQuery * q)"""
    return _gnucash_core_c.qof_query_destroy(q)

def qof_query_search_for(query: 'QofQuery *', obj_type: 'QofIdTypeConst') -> "void":
    """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: 'QofQuery *', book: 'QofBook *') -> "void":
    """qof_query_set_book(QofQuery * q, QofBook * book)"""
    return _gnucash_core_c.qof_query_set_book(q, book)

def qof_query_add_term(query: 'QofQuery *', param_list: 'QofQueryParamList *', pred_data: '_QofQueryPredData', op: 'QofQueryOp') -> "void":
    """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: 'QofQuery *', param_list: 'QofQueryParamList *', guid: 'GncGUID', op: 'QofQueryOp') -> "void":
    """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: 'QofQuery *', param_list: 'QofQueryParamList *', guid_list: 'GList *', options: 'QofGuidMatch', op: 'QofQueryOp') -> "void":
    """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: 'QofQuery *', param_list: 'QofQueryParamList *', value: 'gboolean', op: 'QofQueryOp') -> "void":
    """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: 'QofQuery *') -> "GList *":
    """qof_query_run(QofQuery * query) -> GList *"""
    return _gnucash_core_c.qof_query_run(query)

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

def qof_query_run_subquery(subquery: 'QofQuery *', primary_query: 'QofQuery const *') -> "GList *":
    """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: 'QofQuery *') -> "void":
    """qof_query_clear(QofQuery * query)"""
    return _gnucash_core_c.qof_query_clear(query)

def qof_query_purge_terms(q: 'QofQuery *', param_list: 'QofQueryParamList *') -> "void":
    """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: 'QofQuery *') -> "int":
    """qof_query_has_terms(QofQuery * q) -> int"""
    return _gnucash_core_c.qof_query_has_terms(q)

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

def qof_query_has_term_type(q: 'QofQuery *', term_param: 'QofQueryParamList *') -> "gboolean":
    """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: 'QofQuery *', term_param: 'QofQueryParamList *') -> "GSList *":
    """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: 'QofQuery *') -> "QofQuery *":
    """qof_query_copy(QofQuery * q) -> QofQuery *"""
    return _gnucash_core_c.qof_query_copy(q)

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

def qof_query_merge(q1: 'QofQuery *', q2: 'QofQuery *', op: 'QofQueryOp') -> "QofQuery *":
    """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: 'QofQuery *', q2: 'QofQuery *', op: 'QofQueryOp') -> "void":
    """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: 'QofQuery *', primary_sort_params: 'QofQueryParamList *', secondary_sort_params: 'QofQueryParamList *', tertiary_sort_params: 'QofQueryParamList *') -> "void":
    """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: 'QofQuery *', prim_op: 'gint', sec_op: 'gint', tert_op: 'gint') -> "void":
    """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: 'QofQuery *', prim_inc: 'gboolean', sec_inc: 'gboolean', tert_inc: 'gboolean') -> "void":
    """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: 'QofQuery *', n: 'int') -> "void":
    """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: 'QofQuery const *', q2: 'QofQuery const *') -> "gboolean":
    """qof_query_equal(QofQuery const * q1, QofQuery const * q2) -> gboolean"""
    return _gnucash_core_c.qof_query_equal(q1, q2)

def qof_query_print(query: 'QofQuery *') -> "void":
    """qof_query_print(QofQuery * query)"""
    return _gnucash_core_c.qof_query_print(query)

def qof_query_get_search_for(q: 'QofQuery const *') -> "QofIdType":
    """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: 'QofQuery *') -> "GList *":
    """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):
    """Proxy of C _QofQueryPredData struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _QofQueryPredData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _QofQueryPredData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type_name"] = _gnucash_core_c._QofQueryPredData_type_name_set
    __swig_getmethods__["type_name"] = _gnucash_core_c._QofQueryPredData_type_name_get
    if _newclass:
        type_name = _swig_property(_gnucash_core_c._QofQueryPredData_type_name_get, _gnucash_core_c._QofQueryPredData_type_name_set)
    __swig_setmethods__["how"] = _gnucash_core_c._QofQueryPredData_how_set
    __swig_getmethods__["how"] = _gnucash_core_c._QofQueryPredData_how_get
    if _newclass:
        how = _swig_property(_gnucash_core_c._QofQueryPredData_how_get, _gnucash_core_c._QofQueryPredData_how_set)

    def __init__(self):
        """__init__(_QofQueryPredData self) -> _QofQueryPredData"""
        this = _gnucash_core_c.new__QofQueryPredData()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete__QofQueryPredData
    __del__ = lambda self: None
_QofQueryPredData_swigregister = _gnucash_core_c._QofQueryPredData_swigregister
_QofQueryPredData_swigregister(_QofQueryPredData)


def qof_query_string_predicate(how: 'QofQueryCompare', str: 'gchar const *', options: 'QofStringMatch', is_regex: 'gboolean') -> "QofQueryPredData *":
    """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: 'QofQueryCompare', options: 'QofDateMatch', date: 'time64') -> "QofQueryPredData *":
    """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: 'QofQueryCompare', options: 'QofNumericMatch', value: '_gnc_numeric') -> "QofQueryPredData *":
    """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: 'QofGuidMatch', guids: 'GList *') -> "QofQueryPredData *":
    """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: 'QofQueryCompare', val: 'gint32') -> "QofQueryPredData *":
    """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: 'QofQueryCompare', val: 'gint64') -> "QofQueryPredData *":
    """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: 'QofQueryCompare', val: 'double') -> "QofQueryPredData *":
    """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: 'QofQueryCompare', val: 'gboolean') -> "QofQueryPredData *":
    """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: 'QofCharMatch', chars: 'gchar const *') -> "QofQueryPredData *":
    """qof_query_char_predicate(QofCharMatch options, gchar const * chars) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_char_predicate(options, chars)

def qof_query_collect_predicate(options: 'QofGuidMatch', coll: 'QofCollection *') -> "QofQueryPredData *":
    """qof_query_collect_predicate(QofGuidMatch options, QofCollection * coll) -> _QofQueryPredData"""
    return _gnucash_core_c.qof_query_collect_predicate(options, coll)

def qof_query_choice_predicate(options: 'QofGuidMatch', guids: 'GList *') -> "QofQueryPredData *":
    """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: '_QofQueryPredData') -> "QofQueryPredData *":
    """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: '_QofQueryPredData') -> "void":
    """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: '_QofQueryPredData') -> "time64 *":
    """qof_query_date_predicate_get_date(_QofQueryPredData pd) -> gboolean"""
    return _gnucash_core_c.qof_query_date_predicate_get_date(pd)

def qof_query_core_to_string(arg1: 'QofType', object: 'gpointer', getter: 'QofParam *') -> "char *":
    """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: 'gpointer', b: 'gpointer', options: 'gint', this_param: 'QofParam *') -> "int":
    """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):
    """Proxy of C _gncGuid struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GncGUID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GncGUID, name)
    __repr__ = _swig_repr
    __swig_setmethods__["reserved"] = _gnucash_core_c.GncGUID_reserved_set
    __swig_getmethods__["reserved"] = _gnucash_core_c.GncGUID_reserved_get
    if _newclass:
        reserved = _swig_property(_gnucash_core_c.GncGUID_reserved_get, _gnucash_core_c.GncGUID_reserved_set)

    def __init__(self):
        """__init__(_gncGuid self) -> GncGUID"""
        this = _gnucash_core_c.new_GncGUID()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_GncGUID
    __del__ = lambda self: None
GncGUID_swigregister = _gnucash_core_c.GncGUID_swigregister
GncGUID_swigregister(GncGUID)


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

def gnc_value_get_guid(value: 'GValue const *') -> "GncGUID const *":
    """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: 'GncGUID') -> "void":
    """guid_replace(GncGUID guid)"""
    return _gnucash_core_c.guid_replace(guid)

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

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

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

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

def guid_free(guid: 'GncGUID') -> "void":
    """guid_free(GncGUID guid)"""
    return _gnucash_core_c.guid_free(guid)

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

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

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

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

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

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

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

def guid_g_hash_table_equal(guid_a: 'gconstpointer', guid_b: 'gconstpointer') -> "gint":
    """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() -> "GHashTable *":
    """guid_hash_table_new() -> GHashTable *"""
    return _gnucash_core_c.guid_hash_table_new()
class _gnc_numeric(_object):
    """Proxy of C _gnc_numeric struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gnc_numeric, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gnc_numeric, name)
    __repr__ = _swig_repr
    __swig_setmethods__["num"] = _gnucash_core_c._gnc_numeric_num_set
    __swig_getmethods__["num"] = _gnucash_core_c._gnc_numeric_num_get
    if _newclass:
        num = _swig_property(_gnucash_core_c._gnc_numeric_num_get, _gnucash_core_c._gnc_numeric_num_set)
    __swig_setmethods__["denom"] = _gnucash_core_c._gnc_numeric_denom_set
    __swig_getmethods__["denom"] = _gnucash_core_c._gnc_numeric_denom_get
    if _newclass:
        denom = _swig_property(_gnucash_core_c._gnc_numeric_denom_get, _gnucash_core_c._gnc_numeric_denom_set)

    def __init__(self):
        """__init__(_gnc_numeric self) -> _gnc_numeric"""
        this = _gnucash_core_c.new__gnc_numeric()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete__gnc_numeric
    __del__ = lambda self: None
_gnc_numeric_swigregister = _gnucash_core_c._gnc_numeric_swigregister
_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: 'gint64', denom: 'gint64') -> "gnc_numeric":
    """gnc_numeric_create(gint64 num, gint64 denom) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_create(num, denom)

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

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

def string_to_gnc_numeric(str: 'gchar const *', n: '_gnc_numeric') -> "gboolean":
    """string_to_gnc_numeric(gchar const * str, _gnc_numeric n) -> gboolean"""
    return _gnucash_core_c.string_to_gnc_numeric(str, n)

def gnc_numeric_error(error_code: 'GNCNumericErrorCode') -> "gnc_numeric":
    """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: 'GNCNumericErrorCode') -> "char const *":
    """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: '_gnc_numeric') -> "gint64":
    """gnc_numeric_num(_gnc_numeric a) -> gint64"""
    return _gnucash_core_c.gnc_numeric_num(a)

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

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

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

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

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

def gnc_numeric_compare(a: '_gnc_numeric', b: '_gnc_numeric') -> "gint":
    """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: '_gnc_numeric') -> "gboolean":
    """gnc_numeric_zero_p(_gnc_numeric a) -> gboolean"""
    return _gnucash_core_c.gnc_numeric_zero_p(a)

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

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

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

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

def gnc_numeric_same(a: '_gnc_numeric', b: '_gnc_numeric', denom: 'gint64', how: 'gint') -> "gint":
    """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: '_gnc_numeric', b: '_gnc_numeric', denom: 'gint64', how: 'gint') -> "gnc_numeric":
    """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: '_gnc_numeric', b: '_gnc_numeric', denom: 'gint64', how: 'gint') -> "gnc_numeric":
    """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: '_gnc_numeric', b: '_gnc_numeric', denom: 'gint64', how: 'gint') -> "gnc_numeric":
    """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: '_gnc_numeric', y: '_gnc_numeric', denom: 'gint64', how: 'gint') -> "gnc_numeric":
    """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: '_gnc_numeric') -> "gnc_numeric":
    """gnc_numeric_neg(_gnc_numeric a) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_neg(a)

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

def gnc_numeric_add_fixed(a: '_gnc_numeric', b: '_gnc_numeric') -> "gnc_numeric":
    """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: '_gnc_numeric', b: '_gnc_numeric') -> "gnc_numeric":
    """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: '_gnc_numeric', denom: 'gint64', how: 'gint') -> "gnc_numeric":
    """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: '_gnc_numeric') -> "gnc_numeric":
    """gnc_numeric_reduce(_gnc_numeric n) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_reduce(n)

def gnc_numeric_to_decimal(a: '_gnc_numeric', max_decimal_places: 'guint8 *') -> "gboolean":
    """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: '_gnc_numeric') -> "gnc_numeric":
    """gnc_numeric_invert(_gnc_numeric num) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_numeric_invert(num)

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

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

def gnc_commodity_namespace_get_type() -> "GType":
    """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_NASDAQ = _gnucash_core_c.GNC_COMMODITY_NS_NASDAQ
GNC_COMMODITY_NS_NYSE = _gnucash_core_c.GNC_COMMODITY_NS_NYSE
GNC_COMMODITY_NS_EUREX = _gnucash_core_c.GNC_COMMODITY_NS_EUREX
GNC_COMMODITY_NS_MUTUAL = _gnucash_core_c.GNC_COMMODITY_NS_MUTUAL
GNC_COMMODITY_NS_AMEX = _gnucash_core_c.GNC_COMMODITY_NS_AMEX
GNC_COMMODITY_NS_ASX = _gnucash_core_c.GNC_COMMODITY_NS_ASX
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() -> "gboolean":
    """gnc_quote_source_fq_installed() -> gboolean"""
    return _gnucash_core_c.gnc_quote_source_fq_installed()

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

def gnc_quote_source_set_fq_installed(version_string: 'char const *', sources_list: 'GList const *') -> "void":
    """gnc_quote_source_set_fq_installed(char const * version_string, GList const * sources_list)"""
    return _gnucash_core_c.gnc_quote_source_set_fq_installed(version_string, sources_list)

def gnc_quote_source_num_entries(type: 'QuoteSourceType') -> "gint":
    """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: 'char const *', supported: 'gboolean') -> "gnc_quote_source *":
    """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: 'char const *') -> "gnc_quote_source *":
    """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: 'QuoteSourceType', index: 'gint') -> "gnc_quote_source *":
    """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: 'gnc_quote_source const *') -> "gboolean":
    """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: 'gnc_quote_source const *') -> "QuoteSourceType":
    """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: 'gnc_quote_source const *') -> "gint":
    """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: 'gnc_quote_source const *') -> "char const *":
    """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: 'gnc_quote_source const *') -> "char const *":
    """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: 'QofBook *', fullname: 'char const *', commodity_namespace: 'char const *', mnemonic: 'char const *', cusip: 'char const *', fraction: 'int') -> "gnc_commodity *":
    """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: 'gnc_commodity *') -> "void":
    """gnc_commodity_destroy(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_destroy(cm)

def gnc_commodity_copy(dest: 'gnc_commodity *', src: 'gnc_commodity const *') -> "void":
    """gnc_commodity_copy(gnc_commodity * dest, gnc_commodity const * src)"""
    return _gnucash_core_c.gnc_commodity_copy(dest, src)

def gnc_commodity_clone(src: 'gnc_commodity const *', dest_book: 'QofBook *') -> "gnc_commodity *":
    """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_mnemonic(cm: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "gnc_commodity_namespace *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "int":
    """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: 'gnc_commodity const *') -> "gboolean":
    """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: 'gnc_commodity const *') -> "gnc_quote_source *":
    """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: 'gnc_commodity const *') -> "gnc_quote_source *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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: 'gnc_commodity const *') -> "char const *":
    """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_mnemonic(cm: 'gnc_commodity *', mnemonic: 'char const *') -> "void":
    """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: 'gnc_commodity *', new_namespace: 'char const *') -> "void":
    """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: 'gnc_commodity *', fullname: 'char const *') -> "void":
    """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: 'gnc_commodity *', cusip: 'char const *') -> "void":
    """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: 'gnc_commodity *', smallest_fraction: 'int') -> "void":
    """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: 'gnc_commodity *', flag: 'gboolean const') -> "void":
    """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: 'gnc_commodity *', flag: 'gboolean const') -> "void":
    """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: 'gnc_commodity *', src: 'gnc_quote_source *') -> "void":
    """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: 'gnc_commodity *', tz: 'char const *') -> "void":
    """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: 'gnc_commodity *', user_symbol: 'char const *') -> "void":
    """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: 'gnc_commodity *') -> "void":
    """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: 'gnc_commodity *') -> "void":
    """gnc_commodity_decrement_usage_count(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_decrement_usage_count(cm)

def gnc_commodity_equiv(a: 'gnc_commodity const *', b: 'gnc_commodity const *') -> "gboolean":
    """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: 'gnc_commodity const *', b: 'gnc_commodity const *') -> "gboolean":
    """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: 'gnc_commodity const *', b: 'gnc_commodity const *') -> "int":
    """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: 'void const *', b: 'void const *') -> "int":
    """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: 'char const *') -> "gboolean":
    """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: 'gnc_commodity const *') -> "gboolean":
    """gnc_commodity_is_iso(gnc_commodity const * cm) -> gboolean"""
    return _gnucash_core_c.gnc_commodity_is_iso(cm)

def gnc_commodity_is_currency(cm: 'gnc_commodity const *') -> "gboolean":
    """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: 'QofBook *') -> "gnc_commodity_table *":
    """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: 'gnc_commodity_table const *', commodity_namespace: 'char const *', mnemonic: 'char const *') -> "gnc_commodity *":
    """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: 'gnc_commodity_table const *', unique_name: 'char const *') -> "gnc_commodity *":
    """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: 'gnc_commodity_table const *', commodity_namespace: 'char const *', fullname: 'char const *') -> "gnc_commodity *":
    """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: 'GncGUID', book: 'QofBook *') -> "gnc_commodity *":
    """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: 'gnc_commodity_table *', comm: 'gnc_commodity *') -> "gnc_commodity *":
    """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: 'gnc_commodity_table *', comm: 'gnc_commodity *') -> "void":
    """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: 'gnc_commodity_table *', book: 'QofBook *') -> "gboolean":
    """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: 'gnc_commodity_namespace const *') -> "char const *":
    """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: 'gnc_commodity_namespace const *') -> "char const *":
    """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: 'gnc_commodity_namespace const *') -> "GList *":
    """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: 'gnc_commodity_table const *', commodity_namespace: 'char const *') -> "int":
    """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: 'gnc_commodity_table const *') -> "GList *":
    """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: 'gnc_commodity_table const *') -> "GList *":
    """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: 'gnc_commodity_table *', commodity_namespace: 'char const *', book: 'QofBook *') -> "gnc_commodity_namespace *":
    """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: 'gnc_commodity_table const *', commodity_namespace: 'char const *') -> "gnc_commodity_namespace *":
    """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: 'gnc_commodity_table *', commodity_namespace: 'char const *') -> "void":
    """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: 'gnc_commodity_table const *') -> "guint":
    """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: 'gnc_commodity_table const *', commodity_namespace: 'char const *') -> "CommodityList *":
    """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: 'gnc_commodity_table const *') -> "CommodityList *":
    """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: 'gnc_commodity_table const *', f: 'gboolean (*)(gnc_commodity *,gpointer)', user_data: 'gpointer') -> "gboolean":
    """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() -> "gnc_commodity_table *":
    """gnc_commodity_table_new() -> gnc_commodity_table *"""
    return _gnucash_core_c.gnc_commodity_table_new()

def gnc_commodity_table_destroy(table: 'gnc_commodity_table *') -> "void":
    """gnc_commodity_table_destroy(gnc_commodity_table * table)"""
    return _gnucash_core_c.gnc_commodity_table_destroy(table)

def gnc_commodity_obtain_twin(findlike: 'gnc_commodity const *', book: 'QofBook *') -> "gnc_commodity *":
    """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() -> "gboolean":
    """gnc_commodity_table_register() -> gboolean"""
    return _gnucash_core_c.gnc_commodity_table_register()

def gnc_commodity_begin_edit(cm: 'gnc_commodity *') -> "void":
    """gnc_commodity_begin_edit(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_begin_edit(cm)

def gnc_commodity_commit_edit(cm: 'gnc_commodity *') -> "void":
    """gnc_commodity_commit_edit(gnc_commodity * cm)"""
    return _gnucash_core_c.gnc_commodity_commit_edit(cm)
class _gnc_monetary(_object):
    """Proxy of C _gnc_monetary struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gnc_monetary, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gnc_monetary, name)
    __repr__ = _swig_repr
    __swig_setmethods__["commodity"] = _gnucash_core_c._gnc_monetary_commodity_set
    __swig_getmethods__["commodity"] = _gnucash_core_c._gnc_monetary_commodity_get
    if _newclass:
        commodity = _swig_property(_gnucash_core_c._gnc_monetary_commodity_get, _gnucash_core_c._gnc_monetary_commodity_set)
    __swig_setmethods__["value"] = _gnucash_core_c._gnc_monetary_value_set
    __swig_getmethods__["value"] = _gnucash_core_c._gnc_monetary_value_get
    if _newclass:
        value = _swig_property(_gnucash_core_c._gnc_monetary_value_get, _gnucash_core_c._gnc_monetary_value_set)

    def __init__(self):
        """__init__(_gnc_monetary self) -> _gnc_monetary"""
        this = _gnucash_core_c.new__gnc_monetary()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete__gnc_monetary
    __del__ = lambda self: None
_gnc_monetary_swigregister = _gnucash_core_c._gnc_monetary_swigregister
_gnc_monetary_swigregister(_gnc_monetary)


def gnc_monetary_create(commod: 'gnc_commodity *', val: '_gnc_numeric') -> "gnc_monetary":
    """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: '_gnc_monetary') -> "gnc_commodity *":
    """gnc_monetary_commodity(_gnc_monetary a) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_monetary_commodity(a)

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

def gnc_monetary_list_add_monetary(list: 'MonetaryList *', mon: '_gnc_monetary') -> "MonetaryList *":
    """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: 'MonetaryList *', commod: 'gnc_commodity *', value: '_gnc_numeric') -> "MonetaryList *":
    """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: 'MonetaryList *') -> "MonetaryList *":
    """gnc_monetary_list_delete_zeros(MonetaryList * list) -> MonetaryList *"""
    return _gnucash_core_c.gnc_monetary_list_delete_zeros(list)

def gnc_monetary_list_free(list: 'MonetaryList *') -> "void":
    """gnc_monetary_list_free(MonetaryList * list)"""
    return _gnucash_core_c.gnc_monetary_list_free(list)

def gncEntryGetGUID(x: 'GncEntry *') -> "GncGUID const *":
    """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: 'GncOwner const *') -> "QofIdTypeConst":
    """qofOwnerGetType(GncOwner const * owner) -> QofIdTypeConst"""
    return _gnucash_core_c.qofOwnerGetType(owner)

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

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

def qofOwnerSetEntity(owner: 'GncOwner *', ent: 'QofInstance *') -> "void":
    """qofOwnerSetEntity(GncOwner * owner, QofInstance * ent)"""
    return _gnucash_core_c.qofOwnerSetEntity(owner, ent)

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

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

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

def gncOwnerInitUndefined(owner: 'GncOwner *', obj: 'gpointer') -> "void":
    """gncOwnerInitUndefined(GncOwner * owner, gpointer obj)"""
    return _gnucash_core_c.gncOwnerInitUndefined(owner, obj)

def gncOwnerInitCustomer(owner: 'GncOwner *', customer: 'GncCustomer *') -> "void":
    """gncOwnerInitCustomer(GncOwner * owner, GncCustomer * customer)"""
    return _gnucash_core_c.gncOwnerInitCustomer(owner, customer)

def gncOwnerInitJob(owner: 'GncOwner *', job: 'GncJob *') -> "void":
    """gncOwnerInitJob(GncOwner * owner, GncJob * job)"""
    return _gnucash_core_c.gncOwnerInitJob(owner, job)

def gncOwnerInitVendor(owner: 'GncOwner *', vendor: 'GncVendor *') -> "void":
    """gncOwnerInitVendor(GncOwner * owner, GncVendor * vendor)"""
    return _gnucash_core_c.gncOwnerInitVendor(owner, vendor)

def gncOwnerInitEmployee(owner: 'GncOwner *', employee: 'GncEmployee *') -> "void":
    """gncOwnerInitEmployee(GncOwner * owner, GncEmployee * employee)"""
    return _gnucash_core_c.gncOwnerInitEmployee(owner, employee)

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

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

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

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

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

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

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

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

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

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

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

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

def gncOwnerSetActive(owner: 'GncOwner const *', active: 'gboolean') -> "void":
    """gncOwnerSetActive(GncOwner const * owner, gboolean active)"""
    return _gnucash_core_c.gncOwnerSetActive(owner, active)

def gncOwnerCopy(src: 'GncOwner const *', dest: 'GncOwner *') -> "void":
    """gncOwnerCopy(GncOwner const * src, GncOwner * dest)"""
    return _gnucash_core_c.gncOwnerCopy(src, dest)

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

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

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

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

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

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

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

def gncOwnerAttachToLot(owner: 'GncOwner const *', lot: 'GNCLot *') -> "void":
    """gncOwnerAttachToLot(GncOwner const * owner, GNCLot * lot)"""
    return _gnucash_core_c.gncOwnerAttachToLot(owner, lot)

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

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

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

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

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

def gncOwnerCreatePaymentLotSecs(owner: 'GncOwner const *', preset_txn: 'Transaction **', posted_acc: 'Account *', xfer_acc: 'Account *', amount: '_gnc_numeric', exch: '_gnc_numeric', date: 'time64', memo: 'char const *', num: 'char const *') -> "GNCLot *":
    """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: 'GncOwner const *', lots: 'GList *') -> "void":
    """gncOwnerAutoApplyPaymentsWithLots(GncOwner const * owner, GList * lots)"""
    return _gnucash_core_c.gncOwnerAutoApplyPaymentsWithLots(owner, lots)

def gncOwnerApplyPaymentSecs(owner: 'GncOwner const *', preset_txn: 'Transaction **', lots: 'GList *', posted_acc: 'Account *', xfer_acc: 'Account *', amount: '_gnc_numeric', exch: '_gnc_numeric', date: 'time64', memo: 'char const *', num: 'char const *', auto_pay: 'gboolean') -> "void":
    """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(pay_lot: 'GNCLot *', target_value: '_gnc_numeric') -> "Split *":
    """gncOwnerFindOffsettingSplit(GNCLot * pay_lot, _gnc_numeric target_value) -> Split *"""
    return _gnucash_core_c.gncOwnerFindOffsettingSplit(pay_lot, target_value)

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

def gncOwnerSetLotLinkMemo(ll_txn: 'Transaction *') -> "void":
    """gncOwnerSetLotLinkMemo(Transaction * ll_txn)"""
    return _gnucash_core_c.gncOwnerSetLotLinkMemo(ll_txn)

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

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

def gncOwnerGetBalanceInCurrency(owner: 'GncOwner const *', report_currency: 'gnc_commodity const *') -> "gnc_numeric":
    """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() -> "GncOwner *":
    """gncOwnerNew() -> GncOwner *"""
    return _gnucash_core_c.gncOwnerNew()

def gncOwnerFree(owner: 'GncOwner *') -> "void":
    """gncOwnerFree(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerFree(owner)

def gncOwnerBeginEdit(owner: 'GncOwner *') -> "void":
    """gncOwnerBeginEdit(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerBeginEdit(owner)

def gncOwnerCommitEdit(owner: 'GncOwner *') -> "void":
    """gncOwnerCommitEdit(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerCommitEdit(owner)

def gncOwnerDestroy(owner: 'GncOwner *') -> "void":
    """gncOwnerDestroy(GncOwner * owner)"""
    return _gnucash_core_c.gncOwnerDestroy(owner)
GNC_ID_CUSTOMER = _gnucash_core_c.GNC_ID_CUSTOMER

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

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

def gncCustomerDestroy(customer: 'GncCustomer *') -> "void":
    """gncCustomerDestroy(GncCustomer * customer)"""
    return _gnucash_core_c.gncCustomerDestroy(customer)

def gncCustomerBeginEdit(customer: 'GncCustomer *') -> "void":
    """gncCustomerBeginEdit(GncCustomer * customer)"""
    return _gnucash_core_c.gncCustomerBeginEdit(customer)

def gncCustomerCommitEdit(customer: 'GncCustomer *') -> "void":
    """gncCustomerCommitEdit(GncCustomer * customer)"""
    return _gnucash_core_c.gncCustomerCommitEdit(customer)

def gncCustomerSetID(customer: 'GncCustomer *', id: 'char const *') -> "void":
    """gncCustomerSetID(GncCustomer * customer, char const * id)"""
    return _gnucash_core_c.gncCustomerSetID(customer, id)

def gncCustomerSetName(customer: 'GncCustomer *', name: 'char const *') -> "void":
    """gncCustomerSetName(GncCustomer * customer, char const * name)"""
    return _gnucash_core_c.gncCustomerSetName(customer, name)

def gncCustomerSetNotes(customer: 'GncCustomer *', notes: 'char const *') -> "void":
    """gncCustomerSetNotes(GncCustomer * customer, char const * notes)"""
    return _gnucash_core_c.gncCustomerSetNotes(customer, notes)

def gncCustomerSetTerms(customer: 'GncCustomer *', term: 'GncBillTerm *') -> "void":
    """gncCustomerSetTerms(GncCustomer * customer, GncBillTerm * term)"""
    return _gnucash_core_c.gncCustomerSetTerms(customer, term)

def gncCustomerSetTaxIncluded(customer: 'GncCustomer *', taxincl: 'GncTaxIncluded') -> "void":
    """gncCustomerSetTaxIncluded(GncCustomer * customer, GncTaxIncluded taxincl)"""
    return _gnucash_core_c.gncCustomerSetTaxIncluded(customer, taxincl)

def gncCustomerSetActive(customer: 'GncCustomer *', active: 'gboolean') -> "void":
    """gncCustomerSetActive(GncCustomer * customer, gboolean active)"""
    return _gnucash_core_c.gncCustomerSetActive(customer, active)

def gncCustomerSetDiscount(customer: 'GncCustomer *', discount: '_gnc_numeric') -> "void":
    """gncCustomerSetDiscount(GncCustomer * customer, _gnc_numeric discount)"""
    return _gnucash_core_c.gncCustomerSetDiscount(customer, discount)

def gncCustomerSetCredit(customer: 'GncCustomer *', credit: '_gnc_numeric') -> "void":
    """gncCustomerSetCredit(GncCustomer * customer, _gnc_numeric credit)"""
    return _gnucash_core_c.gncCustomerSetCredit(customer, credit)

def gncCustomerSetCurrency(customer: 'GncCustomer *', currency: 'gnc_commodity *') -> "void":
    """gncCustomerSetCurrency(GncCustomer * customer, gnc_commodity * currency)"""
    return _gnucash_core_c.gncCustomerSetCurrency(customer, currency)

def gncCustomerSetTaxTableOverride(customer: 'GncCustomer *', override: 'gboolean') -> "void":
    """gncCustomerSetTaxTableOverride(GncCustomer * customer, gboolean override)"""
    return _gnucash_core_c.gncCustomerSetTaxTableOverride(customer, override)

def gncCustomerSetTaxTable(customer: 'GncCustomer *', table: 'GncTaxTable *') -> "void":
    """gncCustomerSetTaxTable(GncCustomer * customer, GncTaxTable * table)"""
    return _gnucash_core_c.gncCustomerSetTaxTable(customer, table)

def gncCustomerAddJob(customer: 'GncCustomer *', job: 'GncJob *') -> "void":
    """gncCustomerAddJob(GncCustomer * customer, GncJob * job)"""
    return _gnucash_core_c.gncCustomerAddJob(customer, job)

def gncCustomerRemoveJob(customer: 'GncCustomer *', job: 'GncJob *') -> "void":
    """gncCustomerRemoveJob(GncCustomer * customer, GncJob * job)"""
    return _gnucash_core_c.gncCustomerRemoveJob(customer, job)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncCustomerCompare(a: 'GncCustomer const *', b: 'GncCustomer const *') -> "int":
    """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: 'GncCustomer const *', b: 'GncCustomer const *') -> "gboolean":
    """gncCustomerEqual(GncCustomer const * a, GncCustomer const * b) -> gboolean"""
    return _gnucash_core_c.gncCustomerEqual(a, b)

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

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

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

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

def gncCustomerGetCachedBalance(cust: 'GncCustomer *') -> "gnc_numeric const *":
    """gncCustomerGetCachedBalance(GncCustomer * cust) -> _gnc_numeric"""
    return _gnucash_core_c.gncCustomerGetCachedBalance(cust)

def gncCustomerSetCachedBalance(cust: 'GncCustomer *', new_bal: '_gnc_numeric') -> "void":
    """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() -> "GType":
    """gnc_employee_get_type() -> GType"""
    return _gnucash_core_c.gnc_employee_get_type()

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

def gncEmployeeDestroy(employee: 'GncEmployee *') -> "void":
    """gncEmployeeDestroy(GncEmployee * employee)"""
    return _gnucash_core_c.gncEmployeeDestroy(employee)

def gncEmployeeBeginEdit(employee: 'GncEmployee *') -> "void":
    """gncEmployeeBeginEdit(GncEmployee * employee)"""
    return _gnucash_core_c.gncEmployeeBeginEdit(employee)

def gncEmployeeCommitEdit(employee: 'GncEmployee *') -> "void":
    """gncEmployeeCommitEdit(GncEmployee * employee)"""
    return _gnucash_core_c.gncEmployeeCommitEdit(employee)

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

def gncEmployeeSetID(employee: 'GncEmployee *', id: 'char const *') -> "void":
    """gncEmployeeSetID(GncEmployee * employee, char const * id)"""
    return _gnucash_core_c.gncEmployeeSetID(employee, id)

def gncEmployeeSetUsername(employee: 'GncEmployee *', username: 'char const *') -> "void":
    """gncEmployeeSetUsername(GncEmployee * employee, char const * username)"""
    return _gnucash_core_c.gncEmployeeSetUsername(employee, username)

def gncEmployeeSetName(employee: 'GncEmployee *', name: 'char const *') -> "void":
    """gncEmployeeSetName(GncEmployee * employee, char const * name)"""
    return _gnucash_core_c.gncEmployeeSetName(employee, name)

def gncEmployeeSetLanguage(employee: 'GncEmployee *', language: 'char const *') -> "void":
    """gncEmployeeSetLanguage(GncEmployee * employee, char const * language)"""
    return _gnucash_core_c.gncEmployeeSetLanguage(employee, language)

def gncEmployeeSetAcl(employee: 'GncEmployee *', acl: 'char const *') -> "void":
    """gncEmployeeSetAcl(GncEmployee * employee, char const * acl)"""
    return _gnucash_core_c.gncEmployeeSetAcl(employee, acl)

def gncEmployeeSetWorkday(employee: 'GncEmployee *', workday: '_gnc_numeric') -> "void":
    """gncEmployeeSetWorkday(GncEmployee * employee, _gnc_numeric workday)"""
    return _gnucash_core_c.gncEmployeeSetWorkday(employee, workday)

def gncEmployeeSetRate(employee: 'GncEmployee *', rate: '_gnc_numeric') -> "void":
    """gncEmployeeSetRate(GncEmployee * employee, _gnc_numeric rate)"""
    return _gnucash_core_c.gncEmployeeSetRate(employee, rate)

def gncEmployeeSetCurrency(employee: 'GncEmployee *', currency: 'gnc_commodity *') -> "void":
    """gncEmployeeSetCurrency(GncEmployee * employee, gnc_commodity * currency)"""
    return _gnucash_core_c.gncEmployeeSetCurrency(employee, currency)

def gncEmployeeSetActive(employee: 'GncEmployee *', active: 'gboolean') -> "void":
    """gncEmployeeSetActive(GncEmployee * employee, gboolean active)"""
    return _gnucash_core_c.gncEmployeeSetActive(employee, active)

def gncEmployeeSetCCard(employee: 'GncEmployee *', ccard_acc: 'Account *') -> "void":
    """gncEmployeeSetCCard(GncEmployee * employee, Account * ccard_acc)"""
    return _gnucash_core_c.gncEmployeeSetCCard(employee, ccard_acc)

def qofEmployeeSetAddr(employee: 'GncEmployee *', addr_ent: 'QofInstance *') -> "void":
    """qofEmployeeSetAddr(GncEmployee * employee, QofInstance * addr_ent)"""
    return _gnucash_core_c.qofEmployeeSetAddr(employee, addr_ent)

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

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

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

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

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

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

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

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

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

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

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

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

def gncEmployeeLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncEmployee *":
    """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: 'GncEmployee const *', e2: 'GncEmployee const *') -> "gboolean":
    """gncEmployeeEqual(GncEmployee const * e1, GncEmployee const * e2) -> gboolean"""
    return _gnucash_core_c.gncEmployeeEqual(e1, e2)

def gncEmployeeIsDirty(employee: 'GncEmployee const *') -> "gboolean":
    """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() -> "GType":
    """gnc_vendor_get_type() -> GType"""
    return _gnucash_core_c.gnc_vendor_get_type()

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

def gncVendorDestroy(vendor: 'GncVendor *') -> "void":
    """gncVendorDestroy(GncVendor * vendor)"""
    return _gnucash_core_c.gncVendorDestroy(vendor)

def gncVendorSetID(vendor: 'GncVendor *', id: 'char const *') -> "void":
    """gncVendorSetID(GncVendor * vendor, char const * id)"""
    return _gnucash_core_c.gncVendorSetID(vendor, id)

def gncVendorSetName(vendor: 'GncVendor *', name: 'char const *') -> "void":
    """gncVendorSetName(GncVendor * vendor, char const * name)"""
    return _gnucash_core_c.gncVendorSetName(vendor, name)

def gncVendorSetNotes(vendor: 'GncVendor *', notes: 'char const *') -> "void":
    """gncVendorSetNotes(GncVendor * vendor, char const * notes)"""
    return _gnucash_core_c.gncVendorSetNotes(vendor, notes)

def gncVendorSetTerms(vendor: 'GncVendor *', terms: 'GncBillTerm *') -> "void":
    """gncVendorSetTerms(GncVendor * vendor, GncBillTerm * terms)"""
    return _gnucash_core_c.gncVendorSetTerms(vendor, terms)

def gncVendorSetTaxIncluded(vendor: 'GncVendor *', taxincl: 'GncTaxIncluded') -> "void":
    """gncVendorSetTaxIncluded(GncVendor * vendor, GncTaxIncluded taxincl)"""
    return _gnucash_core_c.gncVendorSetTaxIncluded(vendor, taxincl)

def gncVendorSetCurrency(vendor: 'GncVendor *', currency: 'gnc_commodity *') -> "void":
    """gncVendorSetCurrency(GncVendor * vendor, gnc_commodity * currency)"""
    return _gnucash_core_c.gncVendorSetCurrency(vendor, currency)

def gncVendorSetActive(vendor: 'GncVendor *', active: 'gboolean') -> "void":
    """gncVendorSetActive(GncVendor * vendor, gboolean active)"""
    return _gnucash_core_c.gncVendorSetActive(vendor, active)

def gncVendorSetTaxTableOverride(vendor: 'GncVendor *', override: 'gboolean') -> "void":
    """gncVendorSetTaxTableOverride(GncVendor * vendor, gboolean override)"""
    return _gnucash_core_c.gncVendorSetTaxTableOverride(vendor, override)

def gncVendorSetTaxTable(vendor: 'GncVendor *', table: 'GncTaxTable *') -> "void":
    """gncVendorSetTaxTable(GncVendor * vendor, GncTaxTable * table)"""
    return _gnucash_core_c.gncVendorSetTaxTable(vendor, table)

def gncVendorAddJob(vendor: 'GncVendor *', job: 'GncJob *') -> "void":
    """gncVendorAddJob(GncVendor * vendor, GncJob * job)"""
    return _gnucash_core_c.gncVendorAddJob(vendor, job)

def gncVendorRemoveJob(vendor: 'GncVendor *', job: 'GncJob *') -> "void":
    """gncVendorRemoveJob(GncVendor * vendor, GncJob * job)"""
    return _gnucash_core_c.gncVendorRemoveJob(vendor, job)

def gncVendorBeginEdit(vendor: 'GncVendor *') -> "void":
    """gncVendorBeginEdit(GncVendor * vendor)"""
    return _gnucash_core_c.gncVendorBeginEdit(vendor)

def gncVendorCommitEdit(vendor: 'GncVendor *') -> "void":
    """gncVendorCommitEdit(GncVendor * vendor)"""
    return _gnucash_core_c.gncVendorCommitEdit(vendor)

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

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

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

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

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

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

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

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

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

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

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

def gncVendorLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncVendor *":
    """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: 'GncVendor const *', b: 'GncVendor const *') -> "gboolean":
    """gncVendorEqual(GncVendor const * a, GncVendor const * b) -> gboolean"""
    return _gnucash_core_c.gncVendorEqual(a, b)

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

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

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

def gncVendorGetCachedBalance(vend: 'GncVendor *') -> "gnc_numeric const *":
    """gncVendorGetCachedBalance(GncVendor * vend) -> _gnc_numeric"""
    return _gnucash_core_c.gncVendorGetCachedBalance(vend)

def gncVendorSetCachedBalance(vend: 'GncVendor *', new_bal: '_gnc_numeric') -> "void":
    """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() -> "GType":
    """gnc_address_get_type() -> GType"""
    return _gnucash_core_c.gnc_address_get_type()

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

def gncAddressDestroy(addr: 'GncAddress *') -> "void":
    """gncAddressDestroy(GncAddress * addr)"""
    return _gnucash_core_c.gncAddressDestroy(addr)

def gncAddressBeginEdit(addr: 'GncAddress *') -> "void":
    """gncAddressBeginEdit(GncAddress * addr)"""
    return _gnucash_core_c.gncAddressBeginEdit(addr)

def gncAddressCommitEdit(addr: 'GncAddress *') -> "void":
    """gncAddressCommitEdit(GncAddress * addr)"""
    return _gnucash_core_c.gncAddressCommitEdit(addr)

def gncAddressSetName(addr: 'GncAddress *', name: 'char const *') -> "void":
    """gncAddressSetName(GncAddress * addr, char const * name)"""
    return _gnucash_core_c.gncAddressSetName(addr, name)

def gncAddressSetAddr1(addr: 'GncAddress *', addr1: 'char const *') -> "void":
    """gncAddressSetAddr1(GncAddress * addr, char const * addr1)"""
    return _gnucash_core_c.gncAddressSetAddr1(addr, addr1)

def gncAddressSetAddr2(addr: 'GncAddress *', addr2: 'char const *') -> "void":
    """gncAddressSetAddr2(GncAddress * addr, char const * addr2)"""
    return _gnucash_core_c.gncAddressSetAddr2(addr, addr2)

def gncAddressSetAddr3(addr: 'GncAddress *', addr3: 'char const *') -> "void":
    """gncAddressSetAddr3(GncAddress * addr, char const * addr3)"""
    return _gnucash_core_c.gncAddressSetAddr3(addr, addr3)

def gncAddressSetAddr4(addr: 'GncAddress *', addr4: 'char const *') -> "void":
    """gncAddressSetAddr4(GncAddress * addr, char const * addr4)"""
    return _gnucash_core_c.gncAddressSetAddr4(addr, addr4)

def gncAddressSetPhone(addr: 'GncAddress *', phone: 'char const *') -> "void":
    """gncAddressSetPhone(GncAddress * addr, char const * phone)"""
    return _gnucash_core_c.gncAddressSetPhone(addr, phone)

def gncAddressSetFax(addr: 'GncAddress *', fax: 'char const *') -> "void":
    """gncAddressSetFax(GncAddress * addr, char const * fax)"""
    return _gnucash_core_c.gncAddressSetFax(addr, fax)

def gncAddressSetEmail(addr: 'GncAddress *', email: 'char const *') -> "void":
    """gncAddressSetEmail(GncAddress * addr, char const * email)"""
    return _gnucash_core_c.gncAddressSetEmail(addr, email)

def gncAddressClearDirty(address: 'GncAddress *') -> "void":
    """gncAddressClearDirty(GncAddress * address)"""
    return _gnucash_core_c.gncAddressClearDirty(address)

def gncAddressGetName(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetName(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetName(addr)

def gncAddressGetAddr1(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetAddr1(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr1(addr)

def gncAddressGetAddr2(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetAddr2(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr2(addr)

def gncAddressGetAddr3(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetAddr3(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr3(addr)

def gncAddressGetAddr4(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetAddr4(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetAddr4(addr)

def gncAddressGetPhone(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetPhone(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetPhone(addr)

def gncAddressGetFax(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetFax(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetFax(addr)

def gncAddressGetEmail(addr: 'GncAddress const *') -> "char const *":
    """gncAddressGetEmail(GncAddress const * addr) -> char const *"""
    return _gnucash_core_c.gncAddressGetEmail(addr)

def gncAddressIsDirty(addr: 'GncAddress const *') -> "gboolean":
    """gncAddressIsDirty(GncAddress const * addr) -> gboolean"""
    return _gnucash_core_c.gncAddressIsDirty(addr)

def gncAddressCompare(a: 'GncAddress const *', b: 'GncAddress const *') -> "int":
    """gncAddressCompare(GncAddress const * a, GncAddress const * b) -> int"""
    return _gnucash_core_c.gncAddressCompare(a, b)

def gncAddressEqual(a: 'GncAddress const *', b: 'GncAddress const *') -> "gboolean":
    """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() -> "GType":
    """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: 'QofBook *') -> "GncBillTerm *":
    """gncBillTermCreate(QofBook * book) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermCreate(book)

def gncBillTermDestroy(term: 'GncBillTerm *') -> "void":
    """gncBillTermDestroy(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermDestroy(term)

def gncBillTermIncRef(term: 'GncBillTerm *') -> "void":
    """gncBillTermIncRef(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermIncRef(term)

def gncBillTermDecRef(term: 'GncBillTerm *') -> "void":
    """gncBillTermDecRef(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermDecRef(term)

def gncBillTermChanged(term: 'GncBillTerm *') -> "void":
    """gncBillTermChanged(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermChanged(term)

def gncBillTermBeginEdit(term: 'GncBillTerm *') -> "void":
    """gncBillTermBeginEdit(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermBeginEdit(term)

def gncBillTermCommitEdit(term: 'GncBillTerm *') -> "void":
    """gncBillTermCommitEdit(GncBillTerm * term)"""
    return _gnucash_core_c.gncBillTermCommitEdit(term)

def gncBillTermSetName(term: 'GncBillTerm *', name: 'char const *') -> "void":
    """gncBillTermSetName(GncBillTerm * term, char const * name)"""
    return _gnucash_core_c.gncBillTermSetName(term, name)

def gncBillTermSetDescription(term: 'GncBillTerm *', name: 'char const *') -> "void":
    """gncBillTermSetDescription(GncBillTerm * term, char const * name)"""
    return _gnucash_core_c.gncBillTermSetDescription(term, name)

def gncBillTermSetType(term: 'GncBillTerm *', type: 'GncBillTermType') -> "void":
    """gncBillTermSetType(GncBillTerm * term, GncBillTermType type)"""
    return _gnucash_core_c.gncBillTermSetType(term, type)

def gncBillTermSetDueDays(term: 'GncBillTerm *', days: 'gint') -> "void":
    """gncBillTermSetDueDays(GncBillTerm * term, gint days)"""
    return _gnucash_core_c.gncBillTermSetDueDays(term, days)

def gncBillTermSetDiscountDays(term: 'GncBillTerm *', days: 'gint') -> "void":
    """gncBillTermSetDiscountDays(GncBillTerm * term, gint days)"""
    return _gnucash_core_c.gncBillTermSetDiscountDays(term, days)

def gncBillTermSetDiscount(term: 'GncBillTerm *', discount: '_gnc_numeric') -> "void":
    """gncBillTermSetDiscount(GncBillTerm * term, _gnc_numeric discount)"""
    return _gnucash_core_c.gncBillTermSetDiscount(term, discount)

def gncBillTermSetCutoff(term: 'GncBillTerm *', cutoff: 'gint') -> "void":
    """gncBillTermSetCutoff(GncBillTerm * term, gint cutoff)"""
    return _gnucash_core_c.gncBillTermSetCutoff(term, cutoff)

def gncBillTermLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncBillTerm *":
    """gncBillTermLookup(QofBook const * book, GncGUID guid) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermLookup(book, guid)

def gncBillTermLookupByName(book: 'QofBook *', name: 'char const *') -> "GncBillTerm *":
    """gncBillTermLookupByName(QofBook * book, char const * name) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermLookupByName(book, name)

def gncBillTermGetTerms(book: 'QofBook *') -> "GList *":
    """gncBillTermGetTerms(QofBook * book) -> GList *"""
    return _gnucash_core_c.gncBillTermGetTerms(book)

def gncBillTermGetName(term: 'GncBillTerm const *') -> "char const *":
    """gncBillTermGetName(GncBillTerm const * term) -> char const *"""
    return _gnucash_core_c.gncBillTermGetName(term)

def gncBillTermGetDescription(term: 'GncBillTerm const *') -> "char const *":
    """gncBillTermGetDescription(GncBillTerm const * term) -> char const *"""
    return _gnucash_core_c.gncBillTermGetDescription(term)

def gncBillTermGetType(term: 'GncBillTerm const *') -> "GncBillTermType":
    """gncBillTermGetType(GncBillTerm const * term) -> GncBillTermType"""
    return _gnucash_core_c.gncBillTermGetType(term)

def gncBillTermGetDueDays(term: 'GncBillTerm const *') -> "gint":
    """gncBillTermGetDueDays(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetDueDays(term)

def gncBillTermGetDiscountDays(term: 'GncBillTerm const *') -> "gint":
    """gncBillTermGetDiscountDays(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetDiscountDays(term)

def gncBillTermGetDiscount(term: 'GncBillTerm const *') -> "gnc_numeric":
    """gncBillTermGetDiscount(GncBillTerm const * term) -> _gnc_numeric"""
    return _gnucash_core_c.gncBillTermGetDiscount(term)

def gncBillTermGetCutoff(term: 'GncBillTerm const *') -> "gint":
    """gncBillTermGetCutoff(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetCutoff(term)

def gncBillTermIsDirty(term: 'GncBillTerm const *') -> "gboolean":
    """gncBillTermIsDirty(GncBillTerm const * term) -> gboolean"""
    return _gnucash_core_c.gncBillTermIsDirty(term)

def gncBillTermGetParent(term: 'GncBillTerm const *') -> "GncBillTerm *":
    """gncBillTermGetParent(GncBillTerm const * term) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermGetParent(term)

def gncBillTermReturnChild(term: 'GncBillTerm *', make_new: 'gboolean') -> "GncBillTerm *":
    """gncBillTermReturnChild(GncBillTerm * term, gboolean make_new) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermReturnChild(term, make_new)

def gncBillTermGetRefcount(term: 'GncBillTerm const *') -> "gint64":
    """gncBillTermGetRefcount(GncBillTerm const * term) -> gint64"""
    return _gnucash_core_c.gncBillTermGetRefcount(term)

def gncBillTermCompare(a: 'GncBillTerm const *', b: 'GncBillTerm const *') -> "int":
    """gncBillTermCompare(GncBillTerm const * a, GncBillTerm const * b) -> int"""
    return _gnucash_core_c.gncBillTermCompare(a, b)

def gncBillTermEqual(a: 'GncBillTerm const *', b: 'GncBillTerm const *') -> "gboolean":
    """gncBillTermEqual(GncBillTerm const * a, GncBillTerm const * b) -> gboolean"""
    return _gnucash_core_c.gncBillTermEqual(a, b)

def gncBillTermIsFamily(a: 'GncBillTerm const *', b: 'GncBillTerm const *') -> "gboolean":
    """gncBillTermIsFamily(GncBillTerm const * a, GncBillTerm const * b) -> gboolean"""
    return _gnucash_core_c.gncBillTermIsFamily(a, b)

def gncBillTermComputeDueDate(term: 'GncBillTerm const *', post_date: 'time64') -> "time64":
    """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() -> "GType":
    """gnc_invoice_get_type() -> GType"""
    return _gnucash_core_c.gnc_invoice_get_type()

def gncInvoiceCreate(book: 'QofBook *') -> "GncInvoice *":
    """gncInvoiceCreate(QofBook * book) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceCreate(book)

def gncInvoiceDestroy(invoice: 'GncInvoice *') -> "void":
    """gncInvoiceDestroy(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceDestroy(invoice)

def gncInvoiceCopy(other_invoice: 'GncInvoice const *') -> "GncInvoice *":
    """gncInvoiceCopy(GncInvoice const * other_invoice) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceCopy(other_invoice)

def gncInvoiceSetID(invoice: 'GncInvoice *', id: 'char const *') -> "void":
    """gncInvoiceSetID(GncInvoice * invoice, char const * id)"""
    return _gnucash_core_c.gncInvoiceSetID(invoice, id)

def gncInvoiceSetOwner(invoice: 'GncInvoice *', owner: 'GncOwner *') -> "void":
    """gncInvoiceSetOwner(GncInvoice * invoice, GncOwner * owner)"""
    return _gnucash_core_c.gncInvoiceSetOwner(invoice, owner)

def gncInvoiceSetDateOpenedGDate(invoice: 'GncInvoice *', date: 'GDate const *') -> "void":
    """gncInvoiceSetDateOpenedGDate(GncInvoice * invoice, GDate const * date)"""
    return _gnucash_core_c.gncInvoiceSetDateOpenedGDate(invoice, date)

def gncInvoiceSetDateOpened(invoice: 'GncInvoice *', date: 'time64') -> "void":
    """gncInvoiceSetDateOpened(GncInvoice * invoice, time64 date)"""
    return _gnucash_core_c.gncInvoiceSetDateOpened(invoice, date)

def gncInvoiceSetDatePosted(invoice: 'GncInvoice *', date: 'time64') -> "void":
    """gncInvoiceSetDatePosted(GncInvoice * invoice, time64 date)"""
    return _gnucash_core_c.gncInvoiceSetDatePosted(invoice, date)

def gncInvoiceSetTerms(invoice: 'GncInvoice *', terms: 'GncBillTerm *') -> "void":
    """gncInvoiceSetTerms(GncInvoice * invoice, GncBillTerm * terms)"""
    return _gnucash_core_c.gncInvoiceSetTerms(invoice, terms)

def gncInvoiceSetBillingID(invoice: 'GncInvoice *', billing_id: 'char const *') -> "void":
    """gncInvoiceSetBillingID(GncInvoice * invoice, char const * billing_id)"""
    return _gnucash_core_c.gncInvoiceSetBillingID(invoice, billing_id)

def gncInvoiceSetNotes(invoice: 'GncInvoice *', notes: 'char const *') -> "void":
    """gncInvoiceSetNotes(GncInvoice * invoice, char const * notes)"""
    return _gnucash_core_c.gncInvoiceSetNotes(invoice, notes)

def gncInvoiceSetCurrency(invoice: 'GncInvoice *', currency: 'gnc_commodity *') -> "void":
    """gncInvoiceSetCurrency(GncInvoice * invoice, gnc_commodity * currency)"""
    return _gnucash_core_c.gncInvoiceSetCurrency(invoice, currency)

def gncInvoiceSetActive(invoice: 'GncInvoice *', active: 'gboolean') -> "void":
    """gncInvoiceSetActive(GncInvoice * invoice, gboolean active)"""
    return _gnucash_core_c.gncInvoiceSetActive(invoice, active)

def gncInvoiceSetIsCreditNote(invoice: 'GncInvoice *', credit_note: 'gboolean') -> "void":
    """gncInvoiceSetIsCreditNote(GncInvoice * invoice, gboolean credit_note)"""
    return _gnucash_core_c.gncInvoiceSetIsCreditNote(invoice, credit_note)

def gncInvoiceSetBillTo(invoice: 'GncInvoice *', billto: 'GncOwner *') -> "void":
    """gncInvoiceSetBillTo(GncInvoice * invoice, GncOwner * billto)"""
    return _gnucash_core_c.gncInvoiceSetBillTo(invoice, billto)

def gncInvoiceSetToChargeAmount(invoice: 'GncInvoice *', amount: '_gnc_numeric') -> "void":
    """gncInvoiceSetToChargeAmount(GncInvoice * invoice, _gnc_numeric amount)"""
    return _gnucash_core_c.gncInvoiceSetToChargeAmount(invoice, amount)

def gncInvoiceAddEntry(invoice: 'GncInvoice *', entry: 'GncEntry *') -> "void":
    """gncInvoiceAddEntry(GncInvoice * invoice, GncEntry * entry)"""
    return _gnucash_core_c.gncInvoiceAddEntry(invoice, entry)

def gncInvoiceRemoveEntry(invoice: 'GncInvoice *', entry: 'GncEntry *') -> "void":
    """gncInvoiceRemoveEntry(GncInvoice * invoice, GncEntry * entry)"""
    return _gnucash_core_c.gncInvoiceRemoveEntry(invoice, entry)

def gncInvoiceAddPrice(invoice: 'GncInvoice *', price: 'GNCPrice *') -> "void":
    """gncInvoiceAddPrice(GncInvoice * invoice, GNCPrice * price)"""
    return _gnucash_core_c.gncInvoiceAddPrice(invoice, price)

def gncBillAddEntry(bill: 'GncInvoice *', entry: 'GncEntry *') -> "void":
    """gncBillAddEntry(GncInvoice * bill, GncEntry * entry)"""
    return _gnucash_core_c.gncBillAddEntry(bill, entry)

def gncBillRemoveEntry(bill: 'GncInvoice *', entry: 'GncEntry *') -> "void":
    """gncBillRemoveEntry(GncInvoice * bill, GncEntry * entry)"""
    return _gnucash_core_c.gncBillRemoveEntry(bill, entry)

def gncInvoiceSortEntries(invoice: 'GncInvoice *') -> "void":
    """gncInvoiceSortEntries(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceSortEntries(invoice)

def gncInvoiceRemoveEntries(invoice: 'GncInvoice *') -> "void":
    """gncInvoiceRemoveEntries(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceRemoveEntries(invoice)

def gncInvoiceGetID(invoice: 'GncInvoice const *') -> "char const *":
    """gncInvoiceGetID(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetID(invoice)

def gncInvoiceGetOwner(invoice: 'GncInvoice const *') -> "GncOwner const *":
    """gncInvoiceGetOwner(GncInvoice const * invoice) -> GncOwner const *"""
    return _gnucash_core_c.gncInvoiceGetOwner(invoice)

def gncInvoiceGetDateOpened(invoice: 'GncInvoice const *') -> "time64":
    """gncInvoiceGetDateOpened(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDateOpened(invoice)

def gncInvoiceGetDatePosted(invoice: 'GncInvoice const *') -> "time64":
    """gncInvoiceGetDatePosted(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDatePosted(invoice)

def gncInvoiceGetDateDue(invoice: 'GncInvoice const *') -> "time64":
    """gncInvoiceGetDateDue(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDateDue(invoice)

def gncInvoiceGetTerms(invoice: 'GncInvoice const *') -> "GncBillTerm *":
    """gncInvoiceGetTerms(GncInvoice const * invoice) -> GncBillTerm *"""
    return _gnucash_core_c.gncInvoiceGetTerms(invoice)

def gncInvoiceGetBillingID(invoice: 'GncInvoice const *') -> "char const *":
    """gncInvoiceGetBillingID(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetBillingID(invoice)

def gncInvoiceGetNotes(invoice: 'GncInvoice const *') -> "char const *":
    """gncInvoiceGetNotes(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetNotes(invoice)

def gncInvoiceGetOwnerType(invoice: 'GncInvoice const *') -> "GncOwnerType":
    """gncInvoiceGetOwnerType(GncInvoice const * invoice) -> GncOwnerType"""
    return _gnucash_core_c.gncInvoiceGetOwnerType(invoice)

def gncInvoiceGetTypeListForOwnerType(type: 'GncOwnerType const') -> "GList *":
    """gncInvoiceGetTypeListForOwnerType(GncOwnerType const type) -> GList *"""
    return _gnucash_core_c.gncInvoiceGetTypeListForOwnerType(type)

def gncInvoiceGetType(invoice: 'GncInvoice const *') -> "GncInvoiceType":
    """gncInvoiceGetType(GncInvoice const * invoice) -> GncInvoiceType"""
    return _gnucash_core_c.gncInvoiceGetType(invoice)

def gncInvoiceGetTypeString(invoice: 'GncInvoice const *') -> "char const *":
    """gncInvoiceGetTypeString(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetTypeString(invoice)

def gncInvoiceGetCurrency(invoice: 'GncInvoice const *') -> "gnc_commodity *":
    """gncInvoiceGetCurrency(GncInvoice const * invoice) -> gnc_commodity *"""
    return _gnucash_core_c.gncInvoiceGetCurrency(invoice)

def gncInvoiceGetBillTo(invoice: 'GncInvoice *') -> "GncOwner *":
    """gncInvoiceGetBillTo(GncInvoice * invoice) -> GncOwner *"""
    return _gnucash_core_c.gncInvoiceGetBillTo(invoice)

def gncInvoiceGetToChargeAmount(invoice: 'GncInvoice const *') -> "gnc_numeric":
    """gncInvoiceGetToChargeAmount(GncInvoice const * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetToChargeAmount(invoice)

def gncInvoiceGetActive(invoice: 'GncInvoice const *') -> "gboolean":
    """gncInvoiceGetActive(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceGetActive(invoice)

def gncInvoiceGetIsCreditNote(invoice: 'GncInvoice const *') -> "gboolean":
    """gncInvoiceGetIsCreditNote(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceGetIsCreditNote(invoice)

def gncInvoiceGetPostedLot(invoice: 'GncInvoice const *') -> "GNCLot *":
    """gncInvoiceGetPostedLot(GncInvoice const * invoice) -> GNCLot *"""
    return _gnucash_core_c.gncInvoiceGetPostedLot(invoice)

def gncInvoiceGetPostedTxn(invoice: 'GncInvoice const *') -> "Transaction *":
    """gncInvoiceGetPostedTxn(GncInvoice const * invoice) -> Transaction *"""
    return _gnucash_core_c.gncInvoiceGetPostedTxn(invoice)

def gncInvoiceGetPostedAcc(invoice: 'GncInvoice const *') -> "Account *":
    """gncInvoiceGetPostedAcc(GncInvoice const * invoice) -> Account *"""
    return _gnucash_core_c.gncInvoiceGetPostedAcc(invoice)

def gncInvoiceGetTotal(invoice: 'GncInvoice *') -> "gnc_numeric":
    """gncInvoiceGetTotal(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotal(invoice)

def gncInvoiceGetTotalOf(invoice: 'GncInvoice *', type: 'GncEntryPaymentType') -> "gnc_numeric":
    """gncInvoiceGetTotalOf(GncInvoice * invoice, GncEntryPaymentType type) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalOf(invoice, type)

def gncInvoiceGetTotalSubtotal(invoice: 'GncInvoice *') -> "gnc_numeric":
    """gncInvoiceGetTotalSubtotal(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalSubtotal(invoice)

def gncInvoiceGetTotalTax(invoice: 'GncInvoice *') -> "gnc_numeric":
    """gncInvoiceGetTotalTax(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalTax(invoice)

def gncInvoiceGetTotalTaxList(invoice: 'GncInvoice *') -> "AccountValueList *":
    """gncInvoiceGetTotalTaxList(GncInvoice * invoice) -> AccountValueList *"""
    return _gnucash_core_c.gncInvoiceGetTotalTaxList(invoice)

def gncInvoiceGetEntries(invoice: 'GncInvoice *') -> "EntryList *":
    """gncInvoiceGetEntries(GncInvoice * invoice) -> EntryList *"""
    return _gnucash_core_c.gncInvoiceGetEntries(invoice)

def gncInvoiceGetPrice(invoice: 'GncInvoice *', commodity: 'gnc_commodity *') -> "GNCPrice *":
    """gncInvoiceGetPrice(GncInvoice * invoice, gnc_commodity * commodity) -> GNCPrice *"""
    return _gnucash_core_c.gncInvoiceGetPrice(invoice, commodity)

def gncInvoiceAmountPositive(invoice: 'GncInvoice const *') -> "gboolean":
    """gncInvoiceAmountPositive(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceAmountPositive(invoice)

def gncInvoiceGetForeignCurrencies(invoice: 'GncInvoice const *') -> "GHashTable *":
    """gncInvoiceGetForeignCurrencies(GncInvoice const * invoice) -> GHashTable *"""
    return _gnucash_core_c.gncInvoiceGetForeignCurrencies(invoice)

def gncInvoicePostToAccount(invoice: 'GncInvoice *', acc: 'Account *', posted_date: 'time64', due_date: 'time64', memo: 'char const *', accumulatesplits: 'gboolean', autopay: 'gboolean') -> "Transaction *":
    """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: 'GncInvoice *', reset_tax_tables: 'gboolean') -> "gboolean":
    """gncInvoiceUnpost(GncInvoice * invoice, gboolean reset_tax_tables) -> gboolean"""
    return _gnucash_core_c.gncInvoiceUnpost(invoice, reset_tax_tables)

def gncInvoiceAutoApplyPayments(invoice: 'GncInvoice *') -> "void":
    """gncInvoiceAutoApplyPayments(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceAutoApplyPayments(invoice)

def gncInvoiceApplyPayment(invoice: 'GncInvoice const *', txn: 'Transaction *', xfer_acc: 'Account *', amount: '_gnc_numeric', exch: '_gnc_numeric', date: 'time64', memo: 'char const *', num: 'char const *') -> "void":
    """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: 'Transaction const *') -> "GncInvoice *":
    """gncInvoiceGetInvoiceFromTxn(Transaction const * txn) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceGetInvoiceFromTxn(txn)

def gncInvoiceGetInvoiceFromLot(lot: 'GNCLot *') -> "GncInvoice *":
    """gncInvoiceGetInvoiceFromLot(GNCLot * lot) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceGetInvoiceFromLot(lot)

def gncInvoiceLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncInvoice *":
    """gncInvoiceLookup(QofBook const * book, GncGUID guid) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceLookup(book, guid)

def gncInvoiceBeginEdit(invoice: 'GncInvoice *') -> "void":
    """gncInvoiceBeginEdit(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceBeginEdit(invoice)

def gncInvoiceCommitEdit(invoice: 'GncInvoice *') -> "void":
    """gncInvoiceCommitEdit(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceCommitEdit(invoice)

def gncInvoiceCompare(a: 'GncInvoice const *', b: 'GncInvoice const *') -> "int":
    """gncInvoiceCompare(GncInvoice const * a, GncInvoice const * b) -> int"""
    return _gnucash_core_c.gncInvoiceCompare(a, b)

def gncInvoiceIsPosted(invoice: 'GncInvoice const *') -> "gboolean":
    """gncInvoiceIsPosted(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceIsPosted(invoice)

def gncInvoiceIsPaid(invoice: 'GncInvoice const *') -> "gboolean":
    """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_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_ENTRIES = _gnucash_core_c.INVOICE_ENTRIES
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: 'GncInvoice *') -> "QofBook *":
    """gncInvoiceGetBook(GncInvoice * x) -> QofBook *"""
    return _gnucash_core_c.gncInvoiceGetBook(x)

def gncInvoiceEqual(a: 'GncInvoice const *', b: 'GncInvoice const *') -> "gboolean":
    """gncInvoiceEqual(GncInvoice const * a, GncInvoice const * b) -> gboolean"""
    return _gnucash_core_c.gncInvoiceEqual(a, b)

def gncInvoiceRegister() -> "gboolean":
    """gncInvoiceRegister() -> gboolean"""
    return _gnucash_core_c.gncInvoiceRegister()

def gncInvoiceNextID(book: 'QofBook *', owner: 'GncOwner const *') -> "gchar *":
    """gncInvoiceNextID(QofBook * book, GncOwner const * owner) -> gchar *"""
    return _gnucash_core_c.gncInvoiceNextID(book, owner)

def gncInvoiceSetPostedAcc(invoice: 'GncInvoice *', acc: 'Account *') -> "void":
    """gncInvoiceSetPostedAcc(GncInvoice * invoice, Account * acc)"""
    return _gnucash_core_c.gncInvoiceSetPostedAcc(invoice, acc)

def gncInvoiceSetPostedTxn(invoice: 'GncInvoice *', txn: 'Transaction *') -> "void":
    """gncInvoiceSetPostedTxn(GncInvoice * invoice, Transaction * txn)"""
    return _gnucash_core_c.gncInvoiceSetPostedTxn(invoice, txn)

def gncInvoiceSetPostedLot(invoice: 'GncInvoice *', lot: 'GNCLot *') -> "void":
    """gncInvoiceSetPostedLot(GncInvoice * invoice, GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceSetPostedLot(invoice, lot)

def gncInvoiceAttachToLot(invoice: 'GncInvoice *', lot: 'GNCLot *') -> "void":
    """gncInvoiceAttachToLot(GncInvoice * invoice, GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceAttachToLot(invoice, lot)

def gncInvoiceDetachFromLot(lot: 'GNCLot *') -> "void":
    """gncInvoiceDetachFromLot(GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceDetachFromLot(lot)

def gncInvoiceAttachToTxn(invoice: 'GncInvoice *', txn: 'Transaction *') -> "void":
    """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() -> "GType":
    """gnc_job_get_type() -> GType"""
    return _gnucash_core_c.gnc_job_get_type()

def gncJobCreate(book: 'QofBook *') -> "GncJob *":
    """gncJobCreate(QofBook * book) -> GncJob *"""
    return _gnucash_core_c.gncJobCreate(book)

def gncJobDestroy(job: 'GncJob *') -> "void":
    """gncJobDestroy(GncJob * job)"""
    return _gnucash_core_c.gncJobDestroy(job)

def gncJobSetID(job: 'GncJob *', id: 'char const *') -> "void":
    """gncJobSetID(GncJob * job, char const * id)"""
    return _gnucash_core_c.gncJobSetID(job, id)

def gncJobSetName(job: 'GncJob *', jobname: 'char const *') -> "void":
    """gncJobSetName(GncJob * job, char const * jobname)"""
    return _gnucash_core_c.gncJobSetName(job, jobname)

def gncJobSetReference(job: 'GncJob *', owner_reference: 'char const *') -> "void":
    """gncJobSetReference(GncJob * job, char const * owner_reference)"""
    return _gnucash_core_c.gncJobSetReference(job, owner_reference)

def gncJobSetRate(job: 'GncJob *', rate: '_gnc_numeric') -> "void":
    """gncJobSetRate(GncJob * job, _gnc_numeric rate)"""
    return _gnucash_core_c.gncJobSetRate(job, rate)

def gncJobSetOwner(job: 'GncJob *', owner: 'GncOwner *') -> "void":
    """gncJobSetOwner(GncJob * job, GncOwner * owner)"""
    return _gnucash_core_c.gncJobSetOwner(job, owner)

def gncJobSetActive(job: 'GncJob *', active: 'gboolean') -> "void":
    """gncJobSetActive(GncJob * job, gboolean active)"""
    return _gnucash_core_c.gncJobSetActive(job, active)

def gncJobBeginEdit(job: 'GncJob *') -> "void":
    """gncJobBeginEdit(GncJob * job)"""
    return _gnucash_core_c.gncJobBeginEdit(job)

def gncJobCommitEdit(job: 'GncJob *') -> "void":
    """gncJobCommitEdit(GncJob * job)"""
    return _gnucash_core_c.gncJobCommitEdit(job)

def gncJobGetID(job: 'GncJob const *') -> "char const *":
    """gncJobGetID(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetID(job)

def gncJobGetName(job: 'GncJob const *') -> "char const *":
    """gncJobGetName(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetName(job)

def gncJobGetReference(job: 'GncJob const *') -> "char const *":
    """gncJobGetReference(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetReference(job)

def gncJobGetRate(job: 'GncJob const *') -> "gnc_numeric":
    """gncJobGetRate(GncJob const * job) -> _gnc_numeric"""
    return _gnucash_core_c.gncJobGetRate(job)

def gncJobGetOwner(job: 'GncJob *') -> "GncOwner *":
    """gncJobGetOwner(GncJob * job) -> GncOwner *"""
    return _gnucash_core_c.gncJobGetOwner(job)

def gncJobGetActive(job: 'GncJob const *') -> "gboolean":
    """gncJobGetActive(GncJob const * job) -> gboolean"""
    return _gnucash_core_c.gncJobGetActive(job)

def gncJobLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncJob *":
    """gncJobLookup(QofBook const * book, GncGUID guid) -> GncJob *"""
    return _gnucash_core_c.gncJobLookup(book, guid)

def gncJobCompare(a: 'GncJob const *', b: 'GncJob const *') -> "int":
    """gncJobCompare(GncJob const * a, GncJob const * b) -> int"""
    return _gnucash_core_c.gncJobCompare(a, b)

def gncJobEqual(a: 'GncJob const *', b: 'GncJob const *') -> "gboolean":
    """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() -> "GType":
    """gnc_entry_get_type() -> GType"""
    return _gnucash_core_c.gnc_entry_get_type()

def gncEntryDiscountHowToString(how: 'GncDiscountHow') -> "char const *":
    """gncEntryDiscountHowToString(GncDiscountHow how) -> char const *"""
    return _gnucash_core_c.gncEntryDiscountHowToString(how)

def gncEntryDiscountStringToHow(str: 'char const *', how: 'GncDiscountHow *') -> "gboolean":
    """gncEntryDiscountStringToHow(char const * str, GncDiscountHow * how) -> gboolean"""
    return _gnucash_core_c.gncEntryDiscountStringToHow(str, how)

def gncEntryPaymentTypeToString(type: 'GncEntryPaymentType') -> "char const *":
    """gncEntryPaymentTypeToString(GncEntryPaymentType type) -> char const *"""
    return _gnucash_core_c.gncEntryPaymentTypeToString(type)

def gncEntryPaymentStringToType(str: 'char const *', type: 'GncEntryPaymentType *') -> "gboolean":
    """gncEntryPaymentStringToType(char const * str, GncEntryPaymentType * type) -> gboolean"""
    return _gnucash_core_c.gncEntryPaymentStringToType(str, type)

def gncEntryCreate(book: 'QofBook *') -> "GncEntry *":
    """gncEntryCreate(QofBook * book) -> GncEntry *"""
    return _gnucash_core_c.gncEntryCreate(book)

def gncEntryDestroy(entry: 'GncEntry *') -> "void":
    """gncEntryDestroy(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryDestroy(entry)

def gncEntrySetDateGDate(entry: 'GncEntry *', date: 'GDate const *') -> "void":
    """gncEntrySetDateGDate(GncEntry * entry, GDate const * date)"""
    return _gnucash_core_c.gncEntrySetDateGDate(entry, date)

def gncEntrySetDate(entry: 'GncEntry *', date: 'time64') -> "void":
    """gncEntrySetDate(GncEntry * entry, time64 date)"""
    return _gnucash_core_c.gncEntrySetDate(entry, date)

def gncEntrySetDateEntered(entry: 'GncEntry *', date: 'time64') -> "void":
    """gncEntrySetDateEntered(GncEntry * entry, time64 date)"""
    return _gnucash_core_c.gncEntrySetDateEntered(entry, date)

def gncEntrySetDescription(entry: 'GncEntry *', desc: 'char const *') -> "void":
    """gncEntrySetDescription(GncEntry * entry, char const * desc)"""
    return _gnucash_core_c.gncEntrySetDescription(entry, desc)

def gncEntrySetAction(entry: 'GncEntry *', action: 'char const *') -> "void":
    """gncEntrySetAction(GncEntry * entry, char const * action)"""
    return _gnucash_core_c.gncEntrySetAction(entry, action)

def gncEntrySetNotes(entry: 'GncEntry *', notes: 'char const *') -> "void":
    """gncEntrySetNotes(GncEntry * entry, char const * notes)"""
    return _gnucash_core_c.gncEntrySetNotes(entry, notes)

def gncEntrySetQuantity(entry: 'GncEntry *', quantity: '_gnc_numeric') -> "void":
    """gncEntrySetQuantity(GncEntry * entry, _gnc_numeric quantity)"""
    return _gnucash_core_c.gncEntrySetQuantity(entry, quantity)

def gncEntrySetDocQuantity(entry: 'GncEntry *', quantity: '_gnc_numeric', is_cn: 'gboolean') -> "void":
    """gncEntrySetDocQuantity(GncEntry * entry, _gnc_numeric quantity, gboolean is_cn)"""
    return _gnucash_core_c.gncEntrySetDocQuantity(entry, quantity, is_cn)

def gncEntrySetInvAccount(entry: 'GncEntry *', acc: 'Account *') -> "void":
    """gncEntrySetInvAccount(GncEntry * entry, Account * acc)"""
    return _gnucash_core_c.gncEntrySetInvAccount(entry, acc)

def gncEntrySetInvPrice(entry: 'GncEntry *', price: '_gnc_numeric') -> "void":
    """gncEntrySetInvPrice(GncEntry * entry, _gnc_numeric price)"""
    return _gnucash_core_c.gncEntrySetInvPrice(entry, price)

def gncEntrySetInvTaxable(entry: 'GncEntry *', taxable: 'gboolean') -> "void":
    """gncEntrySetInvTaxable(GncEntry * entry, gboolean taxable)"""
    return _gnucash_core_c.gncEntrySetInvTaxable(entry, taxable)

def gncEntrySetInvTaxIncluded(entry: 'GncEntry *', tax_included: 'gboolean') -> "void":
    """gncEntrySetInvTaxIncluded(GncEntry * entry, gboolean tax_included)"""
    return _gnucash_core_c.gncEntrySetInvTaxIncluded(entry, tax_included)

def gncEntrySetInvTaxTable(entry: 'GncEntry *', table: 'GncTaxTable *') -> "void":
    """gncEntrySetInvTaxTable(GncEntry * entry, GncTaxTable * table)"""
    return _gnucash_core_c.gncEntrySetInvTaxTable(entry, table)

def gncEntrySetInvDiscount(entry: 'GncEntry *', discount: '_gnc_numeric') -> "void":
    """gncEntrySetInvDiscount(GncEntry * entry, _gnc_numeric discount)"""
    return _gnucash_core_c.gncEntrySetInvDiscount(entry, discount)

def gncEntrySetInvDiscountType(entry: 'GncEntry *', type: 'GncAmountType') -> "void":
    """gncEntrySetInvDiscountType(GncEntry * entry, GncAmountType type)"""
    return _gnucash_core_c.gncEntrySetInvDiscountType(entry, type)

def gncEntrySetInvDiscountHow(entry: 'GncEntry *', how: 'GncDiscountHow') -> "void":
    """gncEntrySetInvDiscountHow(GncEntry * entry, GncDiscountHow how)"""
    return _gnucash_core_c.gncEntrySetInvDiscountHow(entry, how)

def qofEntrySetInvDiscType(entry: 'GncEntry *', type: 'char const *') -> "void":
    """qofEntrySetInvDiscType(GncEntry * entry, char const * type)"""
    return _gnucash_core_c.qofEntrySetInvDiscType(entry, type)

def qofEntrySetInvDiscHow(entry: 'GncEntry *', type: 'char const *') -> "void":
    """qofEntrySetInvDiscHow(GncEntry * entry, char const * type)"""
    return _gnucash_core_c.qofEntrySetInvDiscHow(entry, type)

def gncEntrySetBillAccount(entry: 'GncEntry *', acc: 'Account *') -> "void":
    """gncEntrySetBillAccount(GncEntry * entry, Account * acc)"""
    return _gnucash_core_c.gncEntrySetBillAccount(entry, acc)

def gncEntrySetBillPrice(entry: 'GncEntry *', price: '_gnc_numeric') -> "void":
    """gncEntrySetBillPrice(GncEntry * entry, _gnc_numeric price)"""
    return _gnucash_core_c.gncEntrySetBillPrice(entry, price)

def gncEntrySetBillTaxable(entry: 'GncEntry *', taxable: 'gboolean') -> "void":
    """gncEntrySetBillTaxable(GncEntry * entry, gboolean taxable)"""
    return _gnucash_core_c.gncEntrySetBillTaxable(entry, taxable)

def gncEntrySetBillTaxIncluded(entry: 'GncEntry *', tax_included: 'gboolean') -> "void":
    """gncEntrySetBillTaxIncluded(GncEntry * entry, gboolean tax_included)"""
    return _gnucash_core_c.gncEntrySetBillTaxIncluded(entry, tax_included)

def gncEntrySetBillTaxTable(entry: 'GncEntry *', table: 'GncTaxTable *') -> "void":
    """gncEntrySetBillTaxTable(GncEntry * entry, GncTaxTable * table)"""
    return _gnucash_core_c.gncEntrySetBillTaxTable(entry, table)

def gncEntrySetBillable(entry: 'GncEntry *', billable: 'gboolean') -> "void":
    """gncEntrySetBillable(GncEntry * entry, gboolean billable)"""
    return _gnucash_core_c.gncEntrySetBillable(entry, billable)

def gncEntrySetBillTo(entry: 'GncEntry *', billto: 'GncOwner *') -> "void":
    """gncEntrySetBillTo(GncEntry * entry, GncOwner * billto)"""
    return _gnucash_core_c.gncEntrySetBillTo(entry, billto)

def gncEntrySetBillPayment(entry: 'GncEntry *', type: 'GncEntryPaymentType') -> "void":
    """gncEntrySetBillPayment(GncEntry * entry, GncEntryPaymentType type)"""
    return _gnucash_core_c.gncEntrySetBillPayment(entry, type)

def gncEntryGetDateGDate(entry: 'GncEntry const *') -> "GDate":
    """gncEntryGetDateGDate(GncEntry const * entry) -> GDate"""
    return _gnucash_core_c.gncEntryGetDateGDate(entry)

def gncEntryGetDate(entry: 'GncEntry const *') -> "time64":
    """gncEntryGetDate(GncEntry const * entry) -> time64"""
    return _gnucash_core_c.gncEntryGetDate(entry)

def gncEntryGetDateEntered(entry: 'GncEntry const *') -> "time64":
    """gncEntryGetDateEntered(GncEntry const * entry) -> time64"""
    return _gnucash_core_c.gncEntryGetDateEntered(entry)

def gncEntryGetDescription(entry: 'GncEntry const *') -> "char const *":
    """gncEntryGetDescription(GncEntry const * entry) -> char const *"""
    return _gnucash_core_c.gncEntryGetDescription(entry)

def gncEntryGetAction(entry: 'GncEntry const *') -> "char const *":
    """gncEntryGetAction(GncEntry const * entry) -> char const *"""
    return _gnucash_core_c.gncEntryGetAction(entry)

def gncEntryGetNotes(notes: 'GncEntry const *') -> "char const *":
    """gncEntryGetNotes(GncEntry const * notes) -> char const *"""
    return _gnucash_core_c.gncEntryGetNotes(notes)

def gncEntryGetQuantity(entry: 'GncEntry const *') -> "gnc_numeric":
    """gncEntryGetQuantity(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetQuantity(entry)

def gncEntryGetDocQuantity(entry: 'GncEntry const *', is_cn: 'gboolean') -> "gnc_numeric":
    """gncEntryGetDocQuantity(GncEntry const * entry, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocQuantity(entry, is_cn)

def gncEntryGetInvAccount(entry: 'GncEntry const *') -> "Account *":
    """gncEntryGetInvAccount(GncEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncEntryGetInvAccount(entry)

def gncEntryGetInvPrice(entry: 'GncEntry const *') -> "gnc_numeric":
    """gncEntryGetInvPrice(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetInvPrice(entry)

def gncEntryGetPrice(entry: 'GncEntry const *', cust_doc: 'gboolean const', net: 'gboolean const') -> "gnc_numeric":
    """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: 'GncEntry const *') -> "gnc_numeric":
    """gncEntryGetInvDiscount(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetInvDiscount(entry)

def gncEntryGetInvDiscountType(entry: 'GncEntry const *') -> "GncAmountType":
    """gncEntryGetInvDiscountType(GncEntry const * entry) -> GncAmountType"""
    return _gnucash_core_c.gncEntryGetInvDiscountType(entry)

def gncEntryGetInvDiscountHow(entry: 'GncEntry const *') -> "GncDiscountHow":
    """gncEntryGetInvDiscountHow(GncEntry const * entry) -> GncDiscountHow"""
    return _gnucash_core_c.gncEntryGetInvDiscountHow(entry)

def qofEntryGetInvDiscType(entry: 'GncEntry const *') -> "char *":
    """qofEntryGetInvDiscType(GncEntry const * entry) -> char *"""
    return _gnucash_core_c.qofEntryGetInvDiscType(entry)

def qofEntryGetInvDiscHow(entry: 'GncEntry const *') -> "char *":
    """qofEntryGetInvDiscHow(GncEntry const * entry) -> char *"""
    return _gnucash_core_c.qofEntryGetInvDiscHow(entry)

def gncEntryGetInvTaxable(entry: 'GncEntry const *') -> "gboolean":
    """gncEntryGetInvTaxable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetInvTaxable(entry)

def gncEntryGetInvTaxIncluded(entry: 'GncEntry const *') -> "gboolean":
    """gncEntryGetInvTaxIncluded(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetInvTaxIncluded(entry)

def gncEntryGetInvTaxTable(entry: 'GncEntry const *') -> "GncTaxTable *":
    """gncEntryGetInvTaxTable(GncEntry const * entry) -> GncTaxTable *"""
    return _gnucash_core_c.gncEntryGetInvTaxTable(entry)

def gncEntryGetBillAccount(entry: 'GncEntry const *') -> "Account *":
    """gncEntryGetBillAccount(GncEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncEntryGetBillAccount(entry)

def gncEntryGetBillPrice(entry: 'GncEntry const *') -> "gnc_numeric":
    """gncEntryGetBillPrice(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBillPrice(entry)

def gncEntryGetBillTaxable(entry: 'GncEntry const *') -> "gboolean":
    """gncEntryGetBillTaxable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillTaxable(entry)

def gncEntryGetBillTaxIncluded(entry: 'GncEntry const *') -> "gboolean":
    """gncEntryGetBillTaxIncluded(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillTaxIncluded(entry)

def gncEntryGetBillTaxTable(entry: 'GncEntry const *') -> "GncTaxTable *":
    """gncEntryGetBillTaxTable(GncEntry const * entry) -> GncTaxTable *"""
    return _gnucash_core_c.gncEntryGetBillTaxTable(entry)

def gncEntryGetBillable(entry: 'GncEntry const *') -> "gboolean":
    """gncEntryGetBillable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillable(entry)

def gncEntryGetBillTo(entry: 'GncEntry *') -> "GncOwner *":
    """gncEntryGetBillTo(GncEntry * entry) -> GncOwner *"""
    return _gnucash_core_c.gncEntryGetBillTo(entry)

def gncEntryGetBillPayment(entry: 'GncEntry const *') -> "GncEntryPaymentType":
    """gncEntryGetBillPayment(GncEntry const * entry) -> GncEntryPaymentType"""
    return _gnucash_core_c.gncEntryGetBillPayment(entry)

def gncEntryCopy(src: 'GncEntry const *', dest: 'GncEntry *', add_entry: 'gboolean') -> "void":
    """gncEntryCopy(GncEntry const * src, GncEntry * dest, gboolean add_entry)"""
    return _gnucash_core_c.gncEntryCopy(src, dest, add_entry)

def gncEntryGetDocValue(entry: 'GncEntry *', round: 'gboolean', is_cust_doc: 'gboolean', is_cn: 'gboolean') -> "gnc_numeric":
    """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: 'GncEntry *', round: 'gboolean', is_cust_doc: 'gboolean', is_cn: 'gboolean') -> "gnc_numeric":
    """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: 'GncEntry *', is_cust_doc: 'gboolean', is_cn: 'gboolean') -> "AccountValueList *":
    """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: 'GncEntry *', round: 'gboolean', is_cust_doc: 'gboolean', is_cn: 'gboolean') -> "gnc_numeric":
    """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: 'GncEntry *', round: 'gboolean', is_cust_doc: 'gboolean') -> "gnc_numeric":
    """gncEntryGetBalValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalValue(entry, round, is_cust_doc)

def gncEntryGetBalTaxValue(entry: 'GncEntry *', round: 'gboolean', is_cust_doc: 'gboolean') -> "gnc_numeric":
    """gncEntryGetBalTaxValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalTaxValue(entry, round, is_cust_doc)

def gncEntryGetBalTaxValues(entry: 'GncEntry *', is_cust_doc: 'gboolean') -> "AccountValueList *":
    """gncEntryGetBalTaxValues(GncEntry * entry, gboolean is_cust_doc) -> AccountValueList *"""
    return _gnucash_core_c.gncEntryGetBalTaxValues(entry, is_cust_doc)

def gncEntryGetBalDiscountValue(entry: 'GncEntry *', round: 'gboolean', is_cust_doc: 'gboolean') -> "gnc_numeric":
    """gncEntryGetBalDiscountValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalDiscountValue(entry, round, is_cust_doc)

def gncEntryComputeValue(qty: '_gnc_numeric', price: '_gnc_numeric', tax_table: 'GncTaxTable const *', tax_included: 'gboolean', discount: '_gnc_numeric', discount_type: 'GncAmountType', discount_how: 'GncDiscountHow', SCU: 'int', value: '_gnc_numeric', discount_value: '_gnc_numeric', tax_values: 'GList **') -> "void":
    """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: 'GncEntry const *') -> "GncOrder *":
    """gncEntryGetOrder(GncEntry const * entry) -> GncOrder *"""
    return _gnucash_core_c.gncEntryGetOrder(entry)

def gncEntryGetInvoice(entry: 'GncEntry const *') -> "GncInvoice *":
    """gncEntryGetInvoice(GncEntry const * entry) -> GncInvoice *"""
    return _gnucash_core_c.gncEntryGetInvoice(entry)

def gncEntryGetBill(entry: 'GncEntry const *') -> "GncInvoice *":
    """gncEntryGetBill(GncEntry const * entry) -> GncInvoice *"""
    return _gnucash_core_c.gncEntryGetBill(entry)

def gncEntryLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncEntry *":
    """gncEntryLookup(QofBook const * book, GncGUID guid) -> GncEntry *"""
    return _gnucash_core_c.gncEntryLookup(book, guid)

def gncEntryIsOpen(entry: 'GncEntry const *') -> "gboolean":
    """gncEntryIsOpen(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryIsOpen(entry)

def gncEntryBeginEdit(entry: 'GncEntry *') -> "void":
    """gncEntryBeginEdit(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryBeginEdit(entry)

def gncEntryCommitEdit(entry: 'GncEntry *') -> "void":
    """gncEntryCommitEdit(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryCommitEdit(entry)

def gncEntryCompare(a: 'GncEntry const *', b: 'GncEntry const *') -> "int":
    """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() -> "GType":
    """gnc_taxtable_get_type() -> GType"""
    return _gnucash_core_c.gnc_taxtable_get_type()

def gncAmountTypeToString(type: 'GncAmountType') -> "char const *":
    """gncAmountTypeToString(GncAmountType type) -> char const *"""
    return _gnucash_core_c.gncAmountTypeToString(type)

def gncAmountStringToType(str: 'char const *', type: 'GncAmountType *') -> "gboolean":
    """gncAmountStringToType(char const * str, GncAmountType * type) -> gboolean"""
    return _gnucash_core_c.gncAmountStringToType(str, type)

def gncTaxIncludedTypeToString(type: 'GncTaxIncluded') -> "char const *":
    """gncTaxIncludedTypeToString(GncTaxIncluded type) -> char const *"""
    return _gnucash_core_c.gncTaxIncludedTypeToString(type)

def gncTaxIncludedStringToType(str: 'char const *', type: 'GncTaxIncluded *') -> "gboolean":
    """gncTaxIncludedStringToType(char const * str, GncTaxIncluded * type) -> gboolean"""
    return _gnucash_core_c.gncTaxIncludedStringToType(str, type)

def gncTaxTableCreate(book: 'QofBook *') -> "GncTaxTable *":
    """gncTaxTableCreate(QofBook * book) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableCreate(book)

def gncTaxTableDestroy(table: 'GncTaxTable *') -> "void":
    """gncTaxTableDestroy(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableDestroy(table)

def gncTaxTableEntryCreate() -> "GncTaxTableEntry *":
    """gncTaxTableEntryCreate() -> GncTaxTableEntry *"""
    return _gnucash_core_c.gncTaxTableEntryCreate()

def gncTaxTableEntryDestroy(entry: 'GncTaxTableEntry *') -> "void":
    """gncTaxTableEntryDestroy(GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableEntryDestroy(entry)

def gncTaxTableSetName(table: 'GncTaxTable *', name: 'char const *') -> "void":
    """gncTaxTableSetName(GncTaxTable * table, char const * name)"""
    return _gnucash_core_c.gncTaxTableSetName(table, name)

def gncTaxTableIncRef(table: 'GncTaxTable *') -> "void":
    """gncTaxTableIncRef(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableIncRef(table)

def gncTaxTableDecRef(table: 'GncTaxTable *') -> "void":
    """gncTaxTableDecRef(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableDecRef(table)

def gncTaxTableEntrySetAccount(entry: 'GncTaxTableEntry *', account: 'Account *') -> "void":
    """gncTaxTableEntrySetAccount(GncTaxTableEntry * entry, Account * account)"""
    return _gnucash_core_c.gncTaxTableEntrySetAccount(entry, account)

def gncTaxTableEntrySetType(entry: 'GncTaxTableEntry *', type: 'GncAmountType') -> "void":
    """gncTaxTableEntrySetType(GncTaxTableEntry * entry, GncAmountType type)"""
    return _gnucash_core_c.gncTaxTableEntrySetType(entry, type)

def gncTaxTableEntrySetAmount(entry: 'GncTaxTableEntry *', amount: '_gnc_numeric') -> "void":
    """gncTaxTableEntrySetAmount(GncTaxTableEntry * entry, _gnc_numeric amount)"""
    return _gnucash_core_c.gncTaxTableEntrySetAmount(entry, amount)

def gncTaxTableAddEntry(table: 'GncTaxTable *', entry: 'GncTaxTableEntry *') -> "void":
    """gncTaxTableAddEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableAddEntry(table, entry)

def gncTaxTableRemoveEntry(table: 'GncTaxTable *', entry: 'GncTaxTableEntry *') -> "void":
    """gncTaxTableRemoveEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableRemoveEntry(table, entry)

def gncTaxTableChanged(table: 'GncTaxTable *') -> "void":
    """gncTaxTableChanged(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableChanged(table)

def gncTaxTableBeginEdit(table: 'GncTaxTable *') -> "void":
    """gncTaxTableBeginEdit(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableBeginEdit(table)

def gncTaxTableCommitEdit(table: 'GncTaxTable *') -> "void":
    """gncTaxTableCommitEdit(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableCommitEdit(table)

def gncTaxTableEqual(a: 'GncTaxTable const *', b: 'GncTaxTable const *') -> "gboolean":
    """gncTaxTableEqual(GncTaxTable const * a, GncTaxTable const * b) -> gboolean"""
    return _gnucash_core_c.gncTaxTableEqual(a, b)

def gncTaxTableLookup(book: 'QofBook const *', guid: 'GncGUID') -> "GncTaxTable *":
    """gncTaxTableLookup(QofBook const * book, GncGUID guid) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableLookup(book, guid)

def gncTaxTableLookupByName(book: 'QofBook *', name: 'char const *') -> "GncTaxTable *":
    """gncTaxTableLookupByName(QofBook * book, char const * name) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableLookupByName(book, name)

def gncTaxTableGetDefault(book: 'QofBook *', type: 'GncOwnerType') -> "GncTaxTable *":
    """gncTaxTableGetDefault(QofBook * book, GncOwnerType type) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableGetDefault(book, type)

def gncTaxTableGetTables(book: 'QofBook *') -> "GncTaxTableList *":
    """gncTaxTableGetTables(QofBook * book) -> GncTaxTableList *"""
    return _gnucash_core_c.gncTaxTableGetTables(book)

def gncTaxTableGetName(table: 'GncTaxTable const *') -> "char const *":
    """gncTaxTableGetName(GncTaxTable const * table) -> char const *"""
    return _gnucash_core_c.gncTaxTableGetName(table)

def gncTaxTableGetParent(table: 'GncTaxTable const *') -> "GncTaxTable *":
    """gncTaxTableGetParent(GncTaxTable const * table) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableGetParent(table)

def gncTaxTableReturnChild(table: 'GncTaxTable *', make_new: 'gboolean') -> "GncTaxTable *":
    """gncTaxTableReturnChild(GncTaxTable * table, gboolean make_new) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableReturnChild(table, make_new)

def gncTaxTableGetEntries(table: 'GncTaxTable const *') -> "GncTaxTableEntryList *":
    """gncTaxTableGetEntries(GncTaxTable const * table) -> GncTaxTableEntryList *"""
    return _gnucash_core_c.gncTaxTableGetEntries(table)

def gncTaxTableGetRefcount(table: 'GncTaxTable const *') -> "gint64":
    """gncTaxTableGetRefcount(GncTaxTable const * table) -> gint64"""
    return _gnucash_core_c.gncTaxTableGetRefcount(table)

def gncTaxTableLastModifiedSecs(table: 'GncTaxTable const *') -> "time64":
    """gncTaxTableLastModifiedSecs(GncTaxTable const * table) -> time64"""
    return _gnucash_core_c.gncTaxTableLastModifiedSecs(table)

def gncTaxTableEntryGetAccount(entry: 'GncTaxTableEntry const *') -> "Account *":
    """gncTaxTableEntryGetAccount(GncTaxTableEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncTaxTableEntryGetAccount(entry)

def gncTaxTableEntryGetType(entry: 'GncTaxTableEntry const *') -> "GncAmountType":
    """gncTaxTableEntryGetType(GncTaxTableEntry const * entry) -> GncAmountType"""
    return _gnucash_core_c.gncTaxTableEntryGetType(entry)

def gncTaxTableEntryGetAmount(entry: 'GncTaxTableEntry const *') -> "gnc_numeric":
    """gncTaxTableEntryGetAmount(GncTaxTableEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncTaxTableEntryGetAmount(entry)

def gncTaxTableCompare(a: 'GncTaxTable const *', b: 'GncTaxTable const *') -> "int":
    """gncTaxTableCompare(GncTaxTable const * a, GncTaxTable const * b) -> int"""
    return _gnucash_core_c.gncTaxTableCompare(a, b)

def gncTaxTableEntryCompare(a: 'GncTaxTableEntry const *', b: 'GncTaxTableEntry const *') -> "int":
    """gncTaxTableEntryCompare(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> int"""
    return _gnucash_core_c.gncTaxTableEntryCompare(a, b)

def gncTaxTableEntryEqual(a: 'GncTaxTableEntry const *', b: 'GncTaxTableEntry const *') -> "gboolean":
    """gncTaxTableEntryEqual(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> gboolean"""
    return _gnucash_core_c.gncTaxTableEntryEqual(a, b)
class _gncAccountValue(_object):
    """Proxy of C _gncAccountValue struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _gncAccountValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _gncAccountValue, name)
    __repr__ = _swig_repr
    __swig_setmethods__["account"] = _gnucash_core_c._gncAccountValue_account_set
    __swig_getmethods__["account"] = _gnucash_core_c._gncAccountValue_account_get
    if _newclass:
        account = _swig_property(_gnucash_core_c._gncAccountValue_account_get, _gnucash_core_c._gncAccountValue_account_set)
    __swig_setmethods__["value"] = _gnucash_core_c._gncAccountValue_value_set
    __swig_getmethods__["value"] = _gnucash_core_c._gncAccountValue_value_get
    if _newclass:
        value = _swig_property(_gnucash_core_c._gncAccountValue_value_get, _gnucash_core_c._gncAccountValue_value_set)

    def __init__(self):
        """__init__(_gncAccountValue self) -> _gncAccountValue"""
        this = _gnucash_core_c.new__gncAccountValue()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gnucash_core_c.delete__gncAccountValue
    __del__ = lambda self: None
_gncAccountValue_swigregister = _gnucash_core_c._gncAccountValue_swigregister
_gncAccountValue_swigregister(_gncAccountValue)


def gncAccountValueAdd(list: 'GList *', acc: 'Account *', value: '_gnc_numeric') -> "GList *":
    """gncAccountValueAdd(GList * list, Account * acc, _gnc_numeric value) -> GList *"""
    return _gnucash_core_c.gncAccountValueAdd(list, acc, value)

def gncAccountValueAddList(l1: 'GList *', l2: 'GList *') -> "GList *":
    """gncAccountValueAddList(GList * l1, GList * l2) -> GList *"""
    return _gnucash_core_c.gncAccountValueAddList(l1, l2)

def gncAccountValueTotal(list: 'GList *') -> "gnc_numeric":
    """gncAccountValueTotal(GList * list) -> _gnc_numeric"""
    return _gnucash_core_c.gncAccountValueTotal(list)

def gncAccountValueDestroy(list: 'GList *') -> "void":
    """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: 'QofBook *', id: 'gchar const *') -> "GncCustomer *":
    """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: 'QofBook *', id: 'gchar const *') -> "GncInvoice *":
    """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: 'QofBook *', id: 'gchar const *') -> "GncInvoice *":
    """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: 'QofBook *', id: 'gchar const *') -> "GncVendor *":
    """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() -> "GType":
    """gnc_price_get_type() -> GType"""
    return _gnucash_core_c.gnc_price_get_type()

def gnc_pricedb_get_type() -> "GType":
    """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_STOCK_SPLIT = _gnucash_core_c.PRICE_SOURCE_STOCK_SPLIT
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: 'QofBook *') -> "GNCPrice *":
    """gnc_price_create(QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_create(book)

def gnc_price_clone(p: 'GNCPrice *', book: 'QofBook *') -> "GNCPrice *":
    """gnc_price_clone(GNCPrice * p, QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_clone(p, book)

def gnc_price_invert(p: 'GNCPrice *') -> "GNCPrice *":
    """gnc_price_invert(GNCPrice * p) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_invert(p)

def gnc_price_ref(p: 'GNCPrice *') -> "void":
    """gnc_price_ref(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_ref(p)

def gnc_price_unref(p: 'GNCPrice *') -> "void":
    """gnc_price_unref(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_unref(p)

def gnc_price_begin_edit(p: 'GNCPrice *') -> "void":
    """gnc_price_begin_edit(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_begin_edit(p)

def gnc_price_commit_edit(p: 'GNCPrice *') -> "void":
    """gnc_price_commit_edit(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_commit_edit(p)

def gnc_price_set_commodity(p: 'GNCPrice *', c: 'gnc_commodity *') -> "void":
    """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: 'GNCPrice *', c: 'gnc_commodity *') -> "void":
    """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: 'GNCPrice *', t: 'time64') -> "void":
    """gnc_price_set_time64(GNCPrice * p, time64 t)"""
    return _gnucash_core_c.gnc_price_set_time64(p, t)

def gnc_price_set_source(p: 'GNCPrice *', source: 'PriceSource') -> "void":
    """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: 'GNCPrice *', s: 'char const *') -> "void":
    """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: 'GNCPrice *', type: 'char const *') -> "void":
    """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: 'GNCPrice *', value: '_gnc_numeric') -> "void":
    """gnc_price_set_value(GNCPrice * p, _gnc_numeric value)"""
    return _gnucash_core_c.gnc_price_set_value(p, value)

def gnc_price_lookup(guid: 'GncGUID', book: 'QofBook *') -> "GNCPrice *":
    """gnc_price_lookup(GncGUID guid, QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_lookup(guid, book)

def gnc_price_get_commodity(p: 'GNCPrice const *') -> "gnc_commodity *":
    """gnc_price_get_commodity(GNCPrice const * p) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_price_get_commodity(p)

def gnc_price_get_currency(p: 'GNCPrice const *') -> "gnc_commodity *":
    """gnc_price_get_currency(GNCPrice const * p) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_price_get_currency(p)

def gnc_price_get_time64(p: 'GNCPrice const *') -> "time64":
    """gnc_price_get_time64(GNCPrice const * p) -> time64"""
    return _gnucash_core_c.gnc_price_get_time64(p)

def gnc_price_get_source(p: 'GNCPrice const *') -> "PriceSource":
    """gnc_price_get_source(GNCPrice const * p) -> PriceSource"""
    return _gnucash_core_c.gnc_price_get_source(p)

def gnc_price_get_source_string(p: 'GNCPrice const *') -> "char const *":
    """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: 'GNCPrice const *') -> "char const *":
    """gnc_price_get_typestr(GNCPrice const * p) -> char const *"""
    return _gnucash_core_c.gnc_price_get_typestr(p)

def gnc_price_get_value(p: 'GNCPrice const *') -> "gnc_numeric":
    """gnc_price_get_value(GNCPrice const * p) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_price_get_value(p)

def gnc_price_equal(p1: 'GNCPrice const *', p2: 'GNCPrice const *') -> "gboolean":
    """gnc_price_equal(GNCPrice const * p1, GNCPrice const * p2) -> gboolean"""
    return _gnucash_core_c.gnc_price_equal(p1, p2)

def gnc_price_print(db: 'GNCPrice *', f: 'FILE *', indent: 'int') -> "void":
    """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: 'PriceList **', p: 'GNCPrice *', check_dupl: 'gboolean') -> "gboolean":
    """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: 'PriceList **', p: 'GNCPrice *') -> "gboolean":
    """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: 'PriceList *') -> "void":
    """gnc_price_list_destroy(PriceList * prices)"""
    return _gnucash_core_c.gnc_price_list_destroy(prices)

def gnc_price_list_equal(prices1: 'PriceList *', prices2: 'PriceList *') -> "gboolean":
    """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: 'QofBook *') -> "GNCPriceDB *":
    """gnc_pricedb_get_db(QofBook * book) -> GNCPriceDB *"""
    return _gnucash_core_c.gnc_pricedb_get_db(book)

def gnc_collection_get_pricedb(col: 'QofCollection *') -> "GNCPriceDB *":
    """gnc_collection_get_pricedb(QofCollection * col) -> GNCPriceDB *"""
    return _gnucash_core_c.gnc_collection_get_pricedb(col)

def gnc_pricedb_destroy(db: 'GNCPriceDB *') -> "void":
    """gnc_pricedb_destroy(GNCPriceDB * db)"""
    return _gnucash_core_c.gnc_pricedb_destroy(db)

def gnc_pricedb_begin_edit(arg1: 'GNCPriceDB *') -> "void":
    """gnc_pricedb_begin_edit(GNCPriceDB * arg1)"""
    return _gnucash_core_c.gnc_pricedb_begin_edit(arg1)

def gnc_pricedb_commit_edit(arg1: 'GNCPriceDB *') -> "void":
    """gnc_pricedb_commit_edit(GNCPriceDB * arg1)"""
    return _gnucash_core_c.gnc_pricedb_commit_edit(arg1)

def gnc_pricedb_set_bulk_update(db: 'GNCPriceDB *', bulk_update: 'gboolean') -> "void":
    """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: 'GNCPriceDB *', p: 'GNCPrice *') -> "gboolean":
    """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: 'GNCPriceDB *', p: 'GNCPrice *') -> "gboolean":
    """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: 'GNCPriceDB *', comm_list: 'GList *', fiscal_end_date: 'GDate *', cutoff: 'time64', source: 'PriceRemoveSourceFlags', keep: 'PriceRemoveKeepOptions') -> "gboolean":
    """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: 'GNCPriceDB *', commodity: 'gnc_commodity const *', currency: 'gnc_commodity const *') -> "GNCPrice *":
    """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: 'GNCPriceDB *', commodity: 'gnc_commodity const *') -> "PriceList *":
    """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: 'GNCPriceDB *', commodity: 'gnc_commodity const *', currency: 'gnc_commodity const *') -> "gboolean":
    """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: 'GNCPriceDB *', commodity: 'gnc_commodity const *', currency: 'gnc_commodity const *') -> "PriceList *":
    """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_at_time64(db: 'GNCPriceDB *', commodity: 'gnc_commodity const *', currency: 'gnc_commodity const *', t: 'time64') -> "GNCPrice *":
    """gnc_pricedb_lookup_at_time64(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_at_time64(db, commodity, currency, t)

def gnc_pricedb_lookup_day_t64(db: 'GNCPriceDB *', commodity: 'gnc_commodity const *', currency: 'gnc_commodity const *', t: 'time64') -> "GNCPrice *":
    """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: 'GNCPriceDB *', c: 'gnc_commodity const *', currency: 'gnc_commodity const *', t: 'time64') -> "GNCPrice *":
    """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: 'GNCPriceDB *', c: 'gnc_commodity const *', t: 'time64') -> "PriceList *":
    """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_latest_before_t64(db: 'GNCPriceDB *', c: 'gnc_commodity *', currency: 'gnc_commodity *', t: 'time64') -> "GNCPrice *":
    """gnc_pricedb_lookup_latest_before_t64(GNCPriceDB * db, gnc_commodity * c, gnc_commodity * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest_before_t64(db, c, currency, t)

def gnc_pricedb_lookup_latest_before_any_currency_t64(db: 'GNCPriceDB *', c: 'gnc_commodity const *', t: 'time64') -> "PriceList *":
    """gnc_pricedb_lookup_latest_before_any_currency_t64(GNCPriceDB * db, gnc_commodity const * c, time64 t) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest_before_any_currency_t64(db, c, t)

def gnc_pricedb_convert_balance_latest_price(pdb: 'GNCPriceDB *', balance: '_gnc_numeric', balance_currency: 'gnc_commodity const *', new_currency: 'gnc_commodity const *') -> "gnc_numeric":
    """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: 'GNCPriceDB *', balance: '_gnc_numeric', balance_currency: 'gnc_commodity const *', new_currency: 'gnc_commodity const *', t: 'time64') -> "gnc_numeric":
    """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_foreach_price(db: 'GNCPriceDB *', f: 'GncPriceForeachFunc', user_data: 'gpointer', stable_order: 'gboolean') -> "gboolean":
    """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: 'GNCPriceDB *', c: 'gnc_commodity const *') -> "int":
    """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: 'GNCPriceDB *', c: 'gnc_commodity const *', n: 'int const') -> "GNCPrice *":
    """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: 'GNCPriceDB *') -> "void":
    """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: 'GNCPriceDB *') -> "guint":
    """gnc_pricedb_get_num_prices(GNCPriceDB * db) -> guint"""
    return _gnucash_core_c.gnc_pricedb_get_num_prices(db)

def gnc_pricedb_equal(db1: 'GNCPriceDB *', db2: 'GNCPriceDB *') -> "gboolean":
    """gnc_pricedb_equal(GNCPriceDB * db1, GNCPriceDB * db2) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_equal(db1, db2)

def gnc_pricedb_print_contents(db: 'GNCPriceDB *', f: 'FILE *') -> "void":
    """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: 'Split *') -> "gnc_numeric":
    """xaccSplitGetCapGains(Split * arg1) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetCapGains(arg1)

def xaccAccountHasTrades(arg1: 'Account const *') -> "gboolean":
    """xaccAccountHasTrades(Account const * arg1) -> gboolean"""
    return _gnucash_core_c.xaccAccountHasTrades(arg1)

def xaccAccountFindEarliestOpenLot(acc: 'Account *', sign: '_gnc_numeric', currency: 'gnc_commodity *') -> "GNCLot *":
    """xaccAccountFindEarliestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
    return _gnucash_core_c.xaccAccountFindEarliestOpenLot(acc, sign, currency)

def xaccAccountFindLatestOpenLot(acc: 'Account *', sign: '_gnc_numeric', currency: 'gnc_commodity *') -> "GNCLot *":
    """xaccAccountFindLatestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
    return _gnucash_core_c.xaccAccountFindLatestOpenLot(acc, sign, currency)

def xaccSplitGetCapGainsSplit(arg1: 'Split const *') -> "Split *":
    """xaccSplitGetCapGainsSplit(Split const * arg1) -> Split *"""
    return _gnucash_core_c.xaccSplitGetCapGainsSplit(arg1)

def xaccSplitGetGainsSourceSplit(arg1: 'Split const *') -> "Split *":
    """xaccSplitGetGainsSourceSplit(Split const * arg1) -> Split *"""
    return _gnucash_core_c.xaccSplitGetGainsSourceSplit(arg1)

def xaccSplitAssign(split: 'Split *') -> "gboolean":
    """xaccSplitAssign(Split * split) -> gboolean"""
    return _gnucash_core_c.xaccSplitAssign(split)

def xaccSplitAssignToLot(split: 'Split *', lot: 'GNCLot *') -> "Split *":
    """xaccSplitAssignToLot(Split * split, GNCLot * lot) -> Split *"""
    return _gnucash_core_c.xaccSplitAssignToLot(split, lot)

def xaccSplitComputeCapGains(split: 'Split *', gain_acc: 'Account *') -> "void":
    """xaccSplitComputeCapGains(Split * split, Account * gain_acc)"""
    return _gnucash_core_c.xaccSplitComputeCapGains(split, gain_acc)

def xaccLotComputeCapGains(lot: 'GNCLot *', gain_acc: 'Account *') -> "void":
    """xaccLotComputeCapGains(GNCLot * lot, Account * gain_acc)"""
    return _gnucash_core_c.xaccLotComputeCapGains(lot, gain_acc)

def xaccScrubLot(lot: 'GNCLot *') -> "gboolean":
    """xaccScrubLot(GNCLot * lot) -> gboolean"""
    return _gnucash_core_c.xaccScrubLot(lot)

def xaccAccountScrubLots(acc: 'Account *') -> "void":
    """xaccAccountScrubLots(Account * acc)"""
    return _gnucash_core_c.xaccAccountScrubLots(acc)

def xaccAccountTreeScrubLots(acc: 'Account *') -> "void":
    """xaccAccountTreeScrubLots(Account * acc)"""
    return _gnucash_core_c.xaccAccountTreeScrubLots(acc)
# This file is compatible with both classic and new-style classes.


