# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.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
if 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
        if fp is not None:
            try:
                _mod = imp.load_module('_gnucash_core_c', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _gnucash_core_c = swig_import_helper()
    del swig_import_helper
else:
    import _gnucash_core_c
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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):
        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(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccSplitGetSlots(*args):
  """xaccSplitGetSlots(Split const * split) -> KvpFrame *"""
  return _gnucash_core_c.xaccSplitGetSlots(*args)

def xaccSplitSetSlots_nc(*args):
  """xaccSplitSetSlots_nc(Split * s, KvpFrame * frm)"""
  return _gnucash_core_c.xaccSplitSetSlots_nc(*args)

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

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

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

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

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

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

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

def xaccSplitSetDateReconciledTS(*args):
  """xaccSplitSetDateReconciledTS(Split * split, Timespec * ts)"""
  return _gnucash_core_c.xaccSplitSetDateReconciledTS(*args)

def xaccSplitGetDateReconciledTS(*args):
  """xaccSplitGetDateReconciledTS(Split const * split, Timespec * ts)"""
  return _gnucash_core_c.xaccSplitGetDateReconciledTS(*args)

def xaccSplitRetDateReconciledTS(*args):
  """xaccSplitRetDateReconciledTS(Split const * split) -> Timespec"""
  return _gnucash_core_c.xaccSplitRetDateReconciledTS(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gnc_account_get_descendants_sorted(*args):
  """gnc_account_get_descendants_sorted(Account const * account) -> AccountList *"""
  return _gnucash_core_c.gnc_account_get_descendants_sorted(*args)
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: self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_AccountClass
    __del__ = lambda self : None;
AccountClass_swigregister = _gnucash_core_c.AccountClass_swigregister
AccountClass_swigregister(AccountClass)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccAccountSetAutoInterestXfer(*args):
  """xaccAccountSetAutoInterestXfer(Account * account, gboolean value)"""
  return _gnucash_core_c.xaccAccountSetAutoInterestXfer(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccAccountGetReconcileLastDate(*args):
  """xaccAccountGetReconcileLastDate(Account const * account, time64 * last_date) -> gboolean"""
  return _gnucash_core_c.xaccAccountGetReconcileLastDate(*args)

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

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

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

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

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

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

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

def xaccAccountClearReconcilePostpone(*args):
  """xaccAccountClearReconcilePostpone(Account * account)"""
  return _gnucash_core_c.xaccAccountClearReconcilePostpone(*args)
PLACEHOLDER_NONE = _gnucash_core_c.PLACEHOLDER_NONE
PLACEHOLDER_THIS = _gnucash_core_c.PLACEHOLDER_THIS
PLACEHOLDER_CHILD = _gnucash_core_c.PLACEHOLDER_CHILD

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccSplitsBeginStagedTransactionTraversals(*args):
  """xaccSplitsBeginStagedTransactionTraversals(SplitList * splits)"""
  return _gnucash_core_c.xaccSplitsBeginStagedTransactionTraversals(*args)

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

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

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

def gnc_account_tree_staged_transaction_traversal(*args):
  """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(*args)

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

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

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

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

def dxaccAccountGetQuoteTZ(*args):
  """dxaccAccountGetQuoteTZ(Account const * account) -> char const *"""
  return _gnucash_core_c.dxaccAccountGetQuoteTZ(*args)
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_NOTES_ = _gnucash_core_c.ACCOUNT_NOTES_
ACCOUNT_BALANCE_ = _gnucash_core_c.ACCOUNT_BALANCE_
ACCOUNT_CLEARED_ = _gnucash_core_c.ACCOUNT_CLEARED_
ACCOUNT_RECONCILED_ = _gnucash_core_c.ACCOUNT_RECONCILED_
ACCOUNT_PRESENT_ = _gnucash_core_c.ACCOUNT_PRESENT_
ACCOUNT_FUTURE_MINIMUM_ = _gnucash_core_c.ACCOUNT_FUTURE_MINIMUM_
ACCOUNT_TAX_RELATED = _gnucash_core_c.ACCOUNT_TAX_RELATED
ACCOUNT_TYPE_ = _gnucash_core_c.ACCOUNT_TYPE_
ACCOUNT_SCU = _gnucash_core_c.ACCOUNT_SCU
ACCOUNT_NSCU = _gnucash_core_c.ACCOUNT_NSCU
ACCOUNT_PARENT = _gnucash_core_c.ACCOUNT_PARENT
ACCOUNT_MATCH_ALL_TYPE = _gnucash_core_c.ACCOUNT_MATCH_ALL_TYPE

def gnc_transaction_get_type():
  """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(*args):
  """xaccMallocTransaction(QofBook * book) -> Transaction *"""
  return _gnucash_core_c.xaccMallocTransaction(*args)

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

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

def xaccTransEqual(*args):
  """
    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(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccTransSetAssociation(*args):
  """xaccTransSetAssociation(Transaction * trans, char const * assoc)"""
  return _gnucash_core_c.xaccTransSetAssociation(*args)

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

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

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

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

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

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

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

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

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

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

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

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

def xaccTransGetFirstAPARAcctSplit(*args):
  """xaccTransGetFirstAPARAcctSplit(Transaction const * trans) -> Split *"""
  return _gnucash_core_c.xaccTransGetFirstAPARAcctSplit(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccTransSetDatePostedTS(*args):
  """xaccTransSetDatePostedTS(Transaction * trans, Timespec const * ts)"""
  return _gnucash_core_c.xaccTransSetDatePostedTS(*args)

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

def xaccTransSetDateEnteredTS(*args):
  """xaccTransSetDateEnteredTS(Transaction * trans, Timespec const * ts)"""
  return _gnucash_core_c.xaccTransSetDateEnteredTS(*args)

def xaccTransSetDateDueTS(*args):
  """xaccTransSetDateDueTS(Transaction * trans, Timespec const * ts)"""
  return _gnucash_core_c.xaccTransSetDateDueTS(*args)

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

def xaccTransGetDatePostedTS(*args):
  """xaccTransGetDatePostedTS(Transaction const * trans, Timespec * ts)"""
  return _gnucash_core_c.xaccTransGetDatePostedTS(*args)

def xaccTransRetDatePostedTS(*args):
  """xaccTransRetDatePostedTS(Transaction const * trans) -> Timespec"""
  return _gnucash_core_c.xaccTransRetDatePostedTS(*args)

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

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

def xaccTransGetDateEnteredTS(*args):
  """xaccTransGetDateEnteredTS(Transaction const * trans, Timespec * ts)"""
  return _gnucash_core_c.xaccTransGetDateEnteredTS(*args)

def xaccTransRetDateEnteredTS(*args):
  """xaccTransRetDateEnteredTS(Transaction const * trans) -> Timespec"""
  return _gnucash_core_c.xaccTransRetDateEnteredTS(*args)

def xaccTransRetDateDueTS(*args):
  """xaccTransRetDateDueTS(Transaction const * trans) -> Timespec"""
  return _gnucash_core_c.xaccTransRetDateDueTS(*args)

def xaccTransGetDateDueTS(*args):
  """xaccTransGetDateDueTS(Transaction const * trans, Timespec * ts)"""
  return _gnucash_core_c.xaccTransGetDateDueTS(*args)

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

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

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

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

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

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

def xaccTransGetVoidTime(*args):
  """xaccTransGetVoidTime(Transaction const * tr) -> Timespec"""
  return _gnucash_core_c.xaccTransGetVoidTime(*args)
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: 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():
  """gnc_lot_get_type() -> GType"""
  return _gnucash_core_c.gnc_lot_get_type()

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

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

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

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

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

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

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

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

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

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

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

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

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

def gnc_lot_get_balance_before(*args):
  """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(*args)

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

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

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

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

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

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

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

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

def gnc_lot_get_slots(*args):
  """gnc_lot_get_slots(GNCLot const * arg1) -> KvpFrame *"""
  return _gnucash_core_c.gnc_lot_get_slots(*args)

def gnc_lot_make_default(*args):
  """gnc_lot_make_default(Account * acc) -> GNCLot *"""
  return _gnucash_core_c.gnc_lot_make_default(*args)
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_run_begin(*args):
  """qof_backend_run_begin(QofBackend * be, QofInstance * inst)"""
  return _gnucash_core_c.qof_backend_run_begin(*args)

def qof_backend_begin_exists(*args):
  """qof_backend_begin_exists(QofBackend const * be) -> gboolean"""
  return _gnucash_core_c.qof_backend_begin_exists(*args)

def qof_backend_run_commit(*args):
  """qof_backend_run_commit(QofBackend * be, QofInstance * inst)"""
  return _gnucash_core_c.qof_backend_run_commit(*args)

def qof_backend_commit_exists(*args):
  """qof_backend_commit_exists(QofBackend const * be) -> gboolean"""
  return _gnucash_core_c.qof_backend_commit_exists(*args)

def qof_backend_set_error(*args):
  """qof_backend_set_error(QofBackend * be, QofBackendError err)"""
  return _gnucash_core_c.qof_backend_set_error(*args)

def qof_backend_get_error(*args):
  """qof_backend_get_error(QofBackend * be) -> QofBackendError"""
  return _gnucash_core_c.qof_backend_get_error(*args)

def qof_backend_check_error(*args):
  """qof_backend_check_error(QofBackend * be) -> gboolean"""
  return _gnucash_core_c.qof_backend_check_error(*args)

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

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

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

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

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

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

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

def qof_session_begin(*args):
  """
    qof_session_begin(QofSession * session, char const * book_id, gboolean ignore_lock, gboolean create, 
        gboolean force)
    """
  return _gnucash_core_c.qof_session_begin(*args)

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

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

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

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

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

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

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

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

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

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

def qof_session_end(*args):
  """qof_session_end(QofSession * session)"""
  return _gnucash_core_c.qof_session_end(*args)
QOF_STDOUT = _gnucash_core_c.QOF_STDOUT

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

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

def qof_session_add_close_hook(*args):
  """qof_session_add_close_hook(GFunc fn, gpointer data)"""
  return _gnucash_core_c.qof_session_add_close_hook(*args)

def qof_session_call_close_hooks(*args):
  """qof_session_call_close_hooks(QofSession * session)"""
  return _gnucash_core_c.qof_session_call_close_hooks(*args)

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

def qof_backend_get_registered_access_method_list():
  """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(*args):
  """qof_session_ensure_all_data_loaded(QofSession * session)"""
  return _gnucash_core_c.qof_session_ensure_all_data_loaded(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def qof_query_add_guid_list_match(*args):
  """
    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(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def qof_query_set_sort_order(*args):
  """
    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(*args)

def qof_query_set_sort_options(*args):
  """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(*args)

def qof_query_set_sort_increasing(*args):
  """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(*args)

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

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

def qof_query_print(*args):
  """qof_query_print(QofQuery * query)"""
  return _gnucash_core_c.qof_query_print(*args)

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

def qof_query_get_books(*args):
  """qof_query_get_books(QofQuery * q) -> GList *"""
  return _gnucash_core_c.qof_query_get_books(*args)
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_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: 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(*args):
  """qof_query_string_predicate(QofQueryCompare how, gchar const * str, QofStringMatch options, gboolean is_regex) -> _QofQueryPredData"""
  return _gnucash_core_c.qof_query_string_predicate(*args)

def qof_query_date_predicate(*args):
  """qof_query_date_predicate(QofQueryCompare how, QofDateMatch options, Timespec date) -> _QofQueryPredData"""
  return _gnucash_core_c.qof_query_date_predicate(*args)

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

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

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

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

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

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

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

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

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

def qof_query_kvp_predicate(*args):
  """qof_query_kvp_predicate(QofQueryCompare how, QofQueryParamList * path, KvpValue const * value) -> _QofQueryPredData"""
  return _gnucash_core_c.qof_query_kvp_predicate(*args)

def qof_query_kvp_predicate_path(*args):
  """qof_query_kvp_predicate_path(QofQueryCompare how, gchar const * path, KvpValue const * value) -> _QofQueryPredData"""
  return _gnucash_core_c.qof_query_kvp_predicate_path(*args)

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

def qof_query_core_predicate_free(*args):
  """qof_query_core_predicate_free(_QofQueryPredData pdata)"""
  return _gnucash_core_c.qof_query_core_predicate_free(*args)

def qof_query_date_predicate_get_date(*args):
  """qof_query_date_predicate_get_date(_QofQueryPredData pd, Timespec * date) -> gboolean"""
  return _gnucash_core_c.qof_query_date_predicate_get_date(*args)

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

def qof_string_number_compare_func(*args):
  """qof_string_number_compare_func(gpointer a, gpointer b, gint options, QofParam * this_param) -> int"""
  return _gnucash_core_c.qof_string_number_compare_func(*args)
GUID_DATA_SIZE = _gnucash_core_c.GUID_DATA_SIZE
class GncGUID(_object):
    """Proxy of C GNC_INTERNAL_GUID 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__["data"] = _gnucash_core_c.GncGUID_data_set
    __swig_getmethods__["data"] = _gnucash_core_c.GncGUID_data_get
    if _newclass:data = _swig_property(_gnucash_core_c.GncGUID_data_get, _gnucash_core_c.GncGUID_data_set)
    __swig_setmethods__["__align_me"] = _gnucash_core_c.GncGUID___align_me_set
    __swig_getmethods__["__align_me"] = _gnucash_core_c.GncGUID___align_me_get
    if _newclass:__align_me = _swig_property(_gnucash_core_c.GncGUID___align_me_get, _gnucash_core_c.GncGUID___align_me_set)
    def __init__(self): 
        """__init__(GNC_INTERNAL_GUID self) -> GncGUID"""
        this = _gnucash_core_c.new_GncGUID()
        try: self.this.append(this)
        except: 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():
  """gnc_guid_get_type() -> GType"""
  return _gnucash_core_c.gnc_guid_get_type()

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

def guid_init():
  """guid_init()"""
  return _gnucash_core_c.guid_init()

def guid_shutdown():
  """guid_shutdown()"""
  return _gnucash_core_c.guid_shutdown()

def guid_new(*args):
  """guid_new(GncGUID guid)"""
  return _gnucash_core_c.guid_new(*args)

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

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

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

def guid_free(*args):
  """guid_free(GncGUID guid)"""
  return _gnucash_core_c.guid_free(*args)

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

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

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

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

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

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

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

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

def guid_hash_table_new():
  """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: 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(*args):
  """gnc_numeric_create(gint64 num, gint64 denom) -> _gnc_numeric"""
  return _gnucash_core_c.gnc_numeric_create(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gnc_numeric_add_with_error(*args):
  """gnc_numeric_add_with_error(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how, _gnc_numeric error) -> _gnc_numeric"""
  return _gnucash_core_c.gnc_numeric_add_with_error(*args)

def gnc_numeric_sub_with_error(*args):
  """gnc_numeric_sub_with_error(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how, _gnc_numeric error) -> _gnc_numeric"""
  return _gnucash_core_c.gnc_numeric_sub_with_error(*args)

def gnc_numeric_mul_with_error(*args):
  """gnc_numeric_mul_with_error(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how, _gnc_numeric error) -> _gnc_numeric"""
  return _gnucash_core_c.gnc_numeric_mul_with_error(*args)

def gnc_numeric_div_with_error(*args):
  """gnc_numeric_div_with_error(_gnc_numeric a, _gnc_numeric b, gint64 denom, gint how, _gnc_numeric error) -> _gnc_numeric"""
  return _gnucash_core_c.gnc_numeric_div_with_error(*args)

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

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

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

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

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

def pwr64(*args):
  """pwr64(gint64 op, int exp) -> gint64"""
  return _gnucash_core_c.pwr64(*args)

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

def gnc_commodity_namespace_get_type():
  """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_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
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():
  """gnc_quote_source_fq_installed() -> gboolean"""
  return _gnucash_core_c.gnc_quote_source_fq_installed()

def gnc_quote_source_set_fq_installed(*args):
  """gnc_quote_source_set_fq_installed(GList const * sources_list)"""
  return _gnucash_core_c.gnc_quote_source_set_fq_installed(*args)

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

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

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

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

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

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

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

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

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

def gnc_commodity_new(*args):
  """
    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(*args)

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

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

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

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

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

def gnc_commodity_get_namespace_compat(*args):
  """gnc_commodity_get_namespace_compat(gnc_commodity const * cm) -> char const *"""
  return _gnucash_core_c.gnc_commodity_get_namespace_compat(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gnc_commodity_table_lookup(*args):
  """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(*args)

def gnc_commodity_table_lookup_unique(*args):
  """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(*args)

def gnc_commodity_table_find_full(*args):
  """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(*args)

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

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

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

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

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

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

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

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

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

def gnc_commodity_table_add_namespace(*args):
  """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(*args)

def gnc_commodity_table_find_namespace(*args):
  """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(*args)

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

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

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

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

def gnc_commodity_table_foreach_commodity(*args):
  """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(*args)

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

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

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

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

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

def gnc_commodity_commit_edit(*args):
  """gnc_commodity_commit_edit(gnc_commodity * cm)"""
  return _gnucash_core_c.gnc_commodity_commit_edit(*args)
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: 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(*args):
  """gnc_monetary_create(gnc_commodity * commod, _gnc_numeric val) -> _gnc_monetary"""
  return _gnucash_core_c.gnc_monetary_create(*args)

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

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

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

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

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

def gnc_monetary_list_free(*args):
  """gnc_monetary_list_free(MonetaryList * list)"""
  return _gnucash_core_c.gnc_monetary_list_free(*args)
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(*args):
  """qofOwnerGetType(GncOwner const * owner) -> QofIdTypeConst"""
  return _gnucash_core_c.qofOwnerGetType(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncOwnerGetSlots(*args):
  """gncOwnerGetSlots(GncOwner * owner) -> KvpFrame *"""
  return _gnucash_core_c.gncOwnerGetSlots(*args)

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

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

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

def gncOwnerFindOffsettingSplit(*args):
  """gncOwnerFindOffsettingSplit(GNCLot * pay_lot, _gnc_numeric target_value) -> Split *"""
  return _gnucash_core_c.gncOwnerFindOffsettingSplit(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncCustomerNextID(*args):
  """gncCustomerNextID(QofBook * book) -> gchar *"""
  return _gnucash_core_c.gncCustomerNextID(*args)
GNC_ID_EMPLOYEE = _gnucash_core_c.GNC_ID_EMPLOYEE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncVendorNextID(*args):
  """gncVendorNextID(QofBook * book) -> gchar *"""
  return _gnucash_core_c.gncVendorNextID(*args)
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():
  """gnc_address_get_type() -> GType"""
  return _gnucash_core_c.gnc_address_get_type()

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

def gncAddressDestroy(*args):
  """gncAddressDestroy(GncAddress * addr)"""
  return _gnucash_core_c.gncAddressDestroy(*args)

def gncAddressBeginEdit(*args):
  """gncAddressBeginEdit(GncAddress * addr)"""
  return _gnucash_core_c.gncAddressBeginEdit(*args)

def gncAddressCommitEdit(*args):
  """gncAddressCommitEdit(GncAddress * addr)"""
  return _gnucash_core_c.gncAddressCommitEdit(*args)

def gncAddressSetName(*args):
  """gncAddressSetName(GncAddress * addr, char const * name)"""
  return _gnucash_core_c.gncAddressSetName(*args)

def gncAddressSetAddr1(*args):
  """gncAddressSetAddr1(GncAddress * addr, char const * addr1)"""
  return _gnucash_core_c.gncAddressSetAddr1(*args)

def gncAddressSetAddr2(*args):
  """gncAddressSetAddr2(GncAddress * addr, char const * addr2)"""
  return _gnucash_core_c.gncAddressSetAddr2(*args)

def gncAddressSetAddr3(*args):
  """gncAddressSetAddr3(GncAddress * addr, char const * addr3)"""
  return _gnucash_core_c.gncAddressSetAddr3(*args)

def gncAddressSetAddr4(*args):
  """gncAddressSetAddr4(GncAddress * addr, char const * addr4)"""
  return _gnucash_core_c.gncAddressSetAddr4(*args)

def gncAddressSetPhone(*args):
  """gncAddressSetPhone(GncAddress * addr, char const * phone)"""
  return _gnucash_core_c.gncAddressSetPhone(*args)

def gncAddressSetFax(*args):
  """gncAddressSetFax(GncAddress * addr, char const * fax)"""
  return _gnucash_core_c.gncAddressSetFax(*args)

def gncAddressSetEmail(*args):
  """gncAddressSetEmail(GncAddress * addr, char const * email)"""
  return _gnucash_core_c.gncAddressSetEmail(*args)

def gncAddressClearDirty(*args):
  """gncAddressClearDirty(GncAddress * address)"""
  return _gnucash_core_c.gncAddressClearDirty(*args)

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

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

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

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

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

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

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

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

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

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

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

def gncBillTermDestroy(*args):
  """gncBillTermDestroy(GncBillTerm * term)"""
  return _gnucash_core_c.gncBillTermDestroy(*args)

def gncBillTermIncRef(*args):
  """gncBillTermIncRef(GncBillTerm * term)"""
  return _gnucash_core_c.gncBillTermIncRef(*args)

def gncBillTermDecRef(*args):
  """gncBillTermDecRef(GncBillTerm * term)"""
  return _gnucash_core_c.gncBillTermDecRef(*args)

def gncBillTermChanged(*args):
  """gncBillTermChanged(GncBillTerm * term)"""
  return _gnucash_core_c.gncBillTermChanged(*args)

def gncBillTermBeginEdit(*args):
  """gncBillTermBeginEdit(GncBillTerm * term)"""
  return _gnucash_core_c.gncBillTermBeginEdit(*args)

def gncBillTermCommitEdit(*args):
  """gncBillTermCommitEdit(GncBillTerm * term)"""
  return _gnucash_core_c.gncBillTermCommitEdit(*args)

def gncBillTermSetName(*args):
  """gncBillTermSetName(GncBillTerm * term, char const * name)"""
  return _gnucash_core_c.gncBillTermSetName(*args)

def gncBillTermSetDescription(*args):
  """gncBillTermSetDescription(GncBillTerm * term, char const * name)"""
  return _gnucash_core_c.gncBillTermSetDescription(*args)

def gncBillTermSetType(*args):
  """gncBillTermSetType(GncBillTerm * term, GncBillTermType type)"""
  return _gnucash_core_c.gncBillTermSetType(*args)

def gncBillTermSetDueDays(*args):
  """gncBillTermSetDueDays(GncBillTerm * term, gint days)"""
  return _gnucash_core_c.gncBillTermSetDueDays(*args)

def gncBillTermSetDiscountDays(*args):
  """gncBillTermSetDiscountDays(GncBillTerm * term, gint days)"""
  return _gnucash_core_c.gncBillTermSetDiscountDays(*args)

def gncBillTermSetDiscount(*args):
  """gncBillTermSetDiscount(GncBillTerm * term, _gnc_numeric discount)"""
  return _gnucash_core_c.gncBillTermSetDiscount(*args)

def gncBillTermSetCutoff(*args):
  """gncBillTermSetCutoff(GncBillTerm * term, gint cutoff)"""
  return _gnucash_core_c.gncBillTermSetCutoff(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncInvoiceDestroy(*args):
  """gncInvoiceDestroy(GncInvoice * invoice)"""
  return _gnucash_core_c.gncInvoiceDestroy(*args)

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

def gncInvoiceSetID(*args):
  """gncInvoiceSetID(GncInvoice * invoice, char const * id)"""
  return _gnucash_core_c.gncInvoiceSetID(*args)

def gncInvoiceSetOwner(*args):
  """gncInvoiceSetOwner(GncInvoice * invoice, GncOwner * owner)"""
  return _gnucash_core_c.gncInvoiceSetOwner(*args)

def gncInvoiceSetDateOpenedGDate(*args):
  """gncInvoiceSetDateOpenedGDate(GncInvoice * invoice, GDate const * date)"""
  return _gnucash_core_c.gncInvoiceSetDateOpenedGDate(*args)

def gncInvoiceSetDateOpened(*args):
  """gncInvoiceSetDateOpened(GncInvoice * invoice, Timespec date)"""
  return _gnucash_core_c.gncInvoiceSetDateOpened(*args)

def gncInvoiceSetDatePosted(*args):
  """gncInvoiceSetDatePosted(GncInvoice * invoice, Timespec date)"""
  return _gnucash_core_c.gncInvoiceSetDatePosted(*args)

def gncInvoiceSetTerms(*args):
  """gncInvoiceSetTerms(GncInvoice * invoice, GncBillTerm * terms)"""
  return _gnucash_core_c.gncInvoiceSetTerms(*args)

def gncInvoiceSetBillingID(*args):
  """gncInvoiceSetBillingID(GncInvoice * invoice, char const * billing_id)"""
  return _gnucash_core_c.gncInvoiceSetBillingID(*args)

def gncInvoiceSetNotes(*args):
  """gncInvoiceSetNotes(GncInvoice * invoice, char const * notes)"""
  return _gnucash_core_c.gncInvoiceSetNotes(*args)

def gncInvoiceSetCurrency(*args):
  """gncInvoiceSetCurrency(GncInvoice * invoice, gnc_commodity * currency)"""
  return _gnucash_core_c.gncInvoiceSetCurrency(*args)

def gncInvoiceSetActive(*args):
  """gncInvoiceSetActive(GncInvoice * invoice, gboolean active)"""
  return _gnucash_core_c.gncInvoiceSetActive(*args)

def gncInvoiceSetIsCreditNote(*args):
  """gncInvoiceSetIsCreditNote(GncInvoice * invoice, gboolean credit_note)"""
  return _gnucash_core_c.gncInvoiceSetIsCreditNote(*args)

def gncInvoiceSetBillTo(*args):
  """gncInvoiceSetBillTo(GncInvoice * invoice, GncOwner * billto)"""
  return _gnucash_core_c.gncInvoiceSetBillTo(*args)

def gncInvoiceSetToChargeAmount(*args):
  """gncInvoiceSetToChargeAmount(GncInvoice * invoice, _gnc_numeric amount)"""
  return _gnucash_core_c.gncInvoiceSetToChargeAmount(*args)

def gncInvoiceAddEntry(*args):
  """gncInvoiceAddEntry(GncInvoice * invoice, GncEntry * entry)"""
  return _gnucash_core_c.gncInvoiceAddEntry(*args)

def gncInvoiceRemoveEntry(*args):
  """gncInvoiceRemoveEntry(GncInvoice * invoice, GncEntry * entry)"""
  return _gnucash_core_c.gncInvoiceRemoveEntry(*args)

def gncInvoiceAddPrice(*args):
  """gncInvoiceAddPrice(GncInvoice * invoice, GNCPrice * price)"""
  return _gnucash_core_c.gncInvoiceAddPrice(*args)

def gncBillAddEntry(*args):
  """gncBillAddEntry(GncInvoice * bill, GncEntry * entry)"""
  return _gnucash_core_c.gncBillAddEntry(*args)

def gncBillRemoveEntry(*args):
  """gncBillRemoveEntry(GncInvoice * bill, GncEntry * entry)"""
  return _gnucash_core_c.gncBillRemoveEntry(*args)

def gncInvoiceSortEntries(*args):
  """gncInvoiceSortEntries(GncInvoice * invoice)"""
  return _gnucash_core_c.gncInvoiceSortEntries(*args)

def gncInvoiceRemoveEntries(*args):
  """gncInvoiceRemoveEntries(GncInvoice * invoice)"""
  return _gnucash_core_c.gncInvoiceRemoveEntries(*args)

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

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

def gncInvoiceGetDateOpened(*args):
  """gncInvoiceGetDateOpened(GncInvoice const * invoice) -> Timespec"""
  return _gnucash_core_c.gncInvoiceGetDateOpened(*args)

def gncInvoiceGetDatePosted(*args):
  """gncInvoiceGetDatePosted(GncInvoice const * invoice) -> Timespec"""
  return _gnucash_core_c.gncInvoiceGetDatePosted(*args)

def gncInvoiceGetDateDue(*args):
  """gncInvoiceGetDateDue(GncInvoice const * invoice) -> Timespec"""
  return _gnucash_core_c.gncInvoiceGetDateDue(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncInvoicePostToAccount(*args):
  """
    gncInvoicePostToAccount(GncInvoice * invoice, Account * acc, Timespec * posted_date, Timespec * due_date, 
        char const * memo, gboolean accumulatesplits, gboolean autopay) -> Transaction *
    """
  return _gnucash_core_c.gncInvoicePostToAccount(*args)

def gncInvoiceUnpost(*args):
  """gncInvoiceUnpost(GncInvoice * invoice, gboolean reset_tax_tables) -> gboolean"""
  return _gnucash_core_c.gncInvoiceUnpost(*args)

def gncInvoiceAutoApplyPayments(*args):
  """gncInvoiceAutoApplyPayments(GncInvoice * invoice)"""
  return _gnucash_core_c.gncInvoiceAutoApplyPayments(*args)

def gncInvoiceApplyPayment(*args):
  """
    gncInvoiceApplyPayment(GncInvoice const * invoice, Transaction * txn, Account * xfer_acc, _gnc_numeric amount, 
        _gnc_numeric exch, Timespec date, char const * memo, char const * num)
    """
  return _gnucash_core_c.gncInvoiceApplyPayment(*args)

def gncInvoiceGetInvoiceFromTxn(*args):
  """gncInvoiceGetInvoiceFromTxn(Transaction const * txn) -> GncInvoice *"""
  return _gnucash_core_c.gncInvoiceGetInvoiceFromTxn(*args)

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

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

def gncInvoiceBeginEdit(*args):
  """gncInvoiceBeginEdit(GncInvoice * invoice)"""
  return _gnucash_core_c.gncInvoiceBeginEdit(*args)

def gncInvoiceCommitEdit(*args):
  """gncInvoiceCommitEdit(GncInvoice * invoice)"""
  return _gnucash_core_c.gncInvoiceCommitEdit(*args)

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

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

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

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

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

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

def gncInvoiceSetPostedAcc(*args):
  """gncInvoiceSetPostedAcc(GncInvoice * invoice, Account * acc)"""
  return _gnucash_core_c.gncInvoiceSetPostedAcc(*args)

def gncInvoiceSetPostedTxn(*args):
  """gncInvoiceSetPostedTxn(GncInvoice * invoice, Transaction * txn)"""
  return _gnucash_core_c.gncInvoiceSetPostedTxn(*args)

def gncInvoiceSetPostedLot(*args):
  """gncInvoiceSetPostedLot(GncInvoice * invoice, GNCLot * lot)"""
  return _gnucash_core_c.gncInvoiceSetPostedLot(*args)
GNC_ID_JOB = _gnucash_core_c.GNC_ID_JOB

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

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

def gncJobDestroy(*args):
  """gncJobDestroy(GncJob * job)"""
  return _gnucash_core_c.gncJobDestroy(*args)

def gncJobSetID(*args):
  """gncJobSetID(GncJob * job, char const * id)"""
  return _gnucash_core_c.gncJobSetID(*args)

def gncJobSetName(*args):
  """gncJobSetName(GncJob * job, char const * jobname)"""
  return _gnucash_core_c.gncJobSetName(*args)

def gncJobSetReference(*args):
  """gncJobSetReference(GncJob * job, char const * owner_reference)"""
  return _gnucash_core_c.gncJobSetReference(*args)

def gncJobSetOwner(*args):
  """gncJobSetOwner(GncJob * job, GncOwner * owner)"""
  return _gnucash_core_c.gncJobSetOwner(*args)

def gncJobSetActive(*args):
  """gncJobSetActive(GncJob * job, gboolean active)"""
  return _gnucash_core_c.gncJobSetActive(*args)

def gncJobBeginEdit(*args):
  """gncJobBeginEdit(GncJob * job)"""
  return _gnucash_core_c.gncJobBeginEdit(*args)

def gncJobCommitEdit(*args):
  """gncJobCommitEdit(GncJob * job)"""
  return _gnucash_core_c.gncJobCommitEdit(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncEntryDestroy(*args):
  """gncEntryDestroy(GncEntry * entry)"""
  return _gnucash_core_c.gncEntryDestroy(*args)

def gncEntrySetDateGDate(*args):
  """gncEntrySetDateGDate(GncEntry * entry, GDate const * date)"""
  return _gnucash_core_c.gncEntrySetDateGDate(*args)

def gncEntrySetDate(*args):
  """gncEntrySetDate(GncEntry * entry, Timespec date)"""
  return _gnucash_core_c.gncEntrySetDate(*args)

def gncEntrySetDateEntered(*args):
  """gncEntrySetDateEntered(GncEntry * entry, Timespec date)"""
  return _gnucash_core_c.gncEntrySetDateEntered(*args)

def gncEntrySetDescription(*args):
  """gncEntrySetDescription(GncEntry * entry, char const * desc)"""
  return _gnucash_core_c.gncEntrySetDescription(*args)

def gncEntrySetAction(*args):
  """gncEntrySetAction(GncEntry * entry, char const * action)"""
  return _gnucash_core_c.gncEntrySetAction(*args)

def gncEntrySetNotes(*args):
  """gncEntrySetNotes(GncEntry * entry, char const * notes)"""
  return _gnucash_core_c.gncEntrySetNotes(*args)

def gncEntrySetQuantity(*args):
  """gncEntrySetQuantity(GncEntry * entry, _gnc_numeric quantity)"""
  return _gnucash_core_c.gncEntrySetQuantity(*args)

def gncEntrySetDocQuantity(*args):
  """gncEntrySetDocQuantity(GncEntry * entry, _gnc_numeric quantity, gboolean is_cn)"""
  return _gnucash_core_c.gncEntrySetDocQuantity(*args)

def gncEntrySetInvAccount(*args):
  """gncEntrySetInvAccount(GncEntry * entry, Account * acc)"""
  return _gnucash_core_c.gncEntrySetInvAccount(*args)

def gncEntrySetInvPrice(*args):
  """gncEntrySetInvPrice(GncEntry * entry, _gnc_numeric price)"""
  return _gnucash_core_c.gncEntrySetInvPrice(*args)

def gncEntrySetInvTaxable(*args):
  """gncEntrySetInvTaxable(GncEntry * entry, gboolean taxable)"""
  return _gnucash_core_c.gncEntrySetInvTaxable(*args)

def gncEntrySetInvTaxIncluded(*args):
  """gncEntrySetInvTaxIncluded(GncEntry * entry, gboolean tax_included)"""
  return _gnucash_core_c.gncEntrySetInvTaxIncluded(*args)

def gncEntrySetInvTaxTable(*args):
  """gncEntrySetInvTaxTable(GncEntry * entry, GncTaxTable * table)"""
  return _gnucash_core_c.gncEntrySetInvTaxTable(*args)

def gncEntrySetInvDiscount(*args):
  """gncEntrySetInvDiscount(GncEntry * entry, _gnc_numeric discount)"""
  return _gnucash_core_c.gncEntrySetInvDiscount(*args)

def gncEntrySetInvDiscountType(*args):
  """gncEntrySetInvDiscountType(GncEntry * entry, GncAmountType type)"""
  return _gnucash_core_c.gncEntrySetInvDiscountType(*args)

def gncEntrySetInvDiscountHow(*args):
  """gncEntrySetInvDiscountHow(GncEntry * entry, GncDiscountHow how)"""
  return _gnucash_core_c.gncEntrySetInvDiscountHow(*args)

def qofEntrySetInvDiscType(*args):
  """qofEntrySetInvDiscType(GncEntry * entry, char const * type)"""
  return _gnucash_core_c.qofEntrySetInvDiscType(*args)

def qofEntrySetInvDiscHow(*args):
  """qofEntrySetInvDiscHow(GncEntry * entry, char const * type)"""
  return _gnucash_core_c.qofEntrySetInvDiscHow(*args)

def gncEntrySetBillAccount(*args):
  """gncEntrySetBillAccount(GncEntry * entry, Account * acc)"""
  return _gnucash_core_c.gncEntrySetBillAccount(*args)

def gncEntrySetBillPrice(*args):
  """gncEntrySetBillPrice(GncEntry * entry, _gnc_numeric price)"""
  return _gnucash_core_c.gncEntrySetBillPrice(*args)

def gncEntrySetBillTaxable(*args):
  """gncEntrySetBillTaxable(GncEntry * entry, gboolean taxable)"""
  return _gnucash_core_c.gncEntrySetBillTaxable(*args)

def gncEntrySetBillTaxIncluded(*args):
  """gncEntrySetBillTaxIncluded(GncEntry * entry, gboolean tax_included)"""
  return _gnucash_core_c.gncEntrySetBillTaxIncluded(*args)

def gncEntrySetBillTaxTable(*args):
  """gncEntrySetBillTaxTable(GncEntry * entry, GncTaxTable * table)"""
  return _gnucash_core_c.gncEntrySetBillTaxTable(*args)

def gncEntrySetBillable(*args):
  """gncEntrySetBillable(GncEntry * entry, gboolean billable)"""
  return _gnucash_core_c.gncEntrySetBillable(*args)

def gncEntrySetBillTo(*args):
  """gncEntrySetBillTo(GncEntry * entry, GncOwner * billto)"""
  return _gnucash_core_c.gncEntrySetBillTo(*args)

def gncEntrySetBillPayment(*args):
  """gncEntrySetBillPayment(GncEntry * entry, GncEntryPaymentType type)"""
  return _gnucash_core_c.gncEntrySetBillPayment(*args)

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

def gncEntryGetDate(*args):
  """gncEntryGetDate(GncEntry const * entry) -> Timespec"""
  return _gnucash_core_c.gncEntryGetDate(*args)

def gncEntryGetDateEntered(*args):
  """gncEntryGetDateEntered(GncEntry const * entry) -> Timespec"""
  return _gnucash_core_c.gncEntryGetDateEntered(*args)

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

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

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

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

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

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

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

def gncEntryGetInvDiscount(*args):
  """gncEntryGetInvDiscount(GncEntry const * entry) -> _gnc_numeric"""
  return _gnucash_core_c.gncEntryGetInvDiscount(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncEntryCopy(*args):
  """gncEntryCopy(GncEntry const * src, GncEntry * dest, gboolean add_entry)"""
  return _gnucash_core_c.gncEntryCopy(*args)

def gncEntryGetDocValue(*args):
  """gncEntryGetDocValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
  return _gnucash_core_c.gncEntryGetDocValue(*args)

def gncEntryGetDocTaxValue(*args):
  """gncEntryGetDocTaxValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
  return _gnucash_core_c.gncEntryGetDocTaxValue(*args)

def gncEntryGetDocTaxValues(*args):
  """gncEntryGetDocTaxValues(GncEntry * entry, gboolean is_cust_doc, gboolean is_cn) -> AccountValueList *"""
  return _gnucash_core_c.gncEntryGetDocTaxValues(*args)

def gncEntryGetDocDiscountValue(*args):
  """gncEntryGetDocDiscountValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
  return _gnucash_core_c.gncEntryGetDocDiscountValue(*args)

def gncEntryGetBalValue(*args):
  """gncEntryGetBalValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
  return _gnucash_core_c.gncEntryGetBalValue(*args)

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

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

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

def gncEntryComputeValue(*args):
  """
    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(*args)

def gncEntryGetOrder(*args):
  """gncEntryGetOrder(GncEntry const * entry) -> GncOrder *"""
  return _gnucash_core_c.gncEntryGetOrder(*args)

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

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

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

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

def gncEntryBeginEdit(*args):
  """gncEntryBeginEdit(GncEntry * entry)"""
  return _gnucash_core_c.gncEntryBeginEdit(*args)

def gncEntryCommitEdit(*args):
  """gncEntryCommitEdit(GncEntry * entry)"""
  return _gnucash_core_c.gncEntryCommitEdit(*args)

def gncEntryCompare(*args):
  """gncEntryCompare(GncEntry const * a, GncEntry const * b) -> int"""
  return _gnucash_core_c.gncEntryCompare(*args)
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_ID_TAXTABLE = _gnucash_core_c.GNC_ID_TAXTABLE

def gnc_taxtable_get_type():
  """gnc_taxtable_get_type() -> GType"""
  return _gnucash_core_c.gnc_taxtable_get_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

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

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

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

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

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

def gncTaxTableDestroy(*args):
  """gncTaxTableDestroy(GncTaxTable * table)"""
  return _gnucash_core_c.gncTaxTableDestroy(*args)

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

def gncTaxTableEntryDestroy(*args):
  """gncTaxTableEntryDestroy(GncTaxTableEntry * entry)"""
  return _gnucash_core_c.gncTaxTableEntryDestroy(*args)

def gncTaxTableSetName(*args):
  """gncTaxTableSetName(GncTaxTable * table, char const * name)"""
  return _gnucash_core_c.gncTaxTableSetName(*args)

def gncTaxTableIncRef(*args):
  """gncTaxTableIncRef(GncTaxTable * table)"""
  return _gnucash_core_c.gncTaxTableIncRef(*args)

def gncTaxTableDecRef(*args):
  """gncTaxTableDecRef(GncTaxTable * table)"""
  return _gnucash_core_c.gncTaxTableDecRef(*args)

def gncTaxTableEntrySetAccount(*args):
  """gncTaxTableEntrySetAccount(GncTaxTableEntry * entry, Account * account)"""
  return _gnucash_core_c.gncTaxTableEntrySetAccount(*args)

def gncTaxTableEntrySetType(*args):
  """gncTaxTableEntrySetType(GncTaxTableEntry * entry, GncAmountType type)"""
  return _gnucash_core_c.gncTaxTableEntrySetType(*args)

def gncTaxTableEntrySetAmount(*args):
  """gncTaxTableEntrySetAmount(GncTaxTableEntry * entry, _gnc_numeric amount)"""
  return _gnucash_core_c.gncTaxTableEntrySetAmount(*args)

def gncTaxTableAddEntry(*args):
  """gncTaxTableAddEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
  return _gnucash_core_c.gncTaxTableAddEntry(*args)

def gncTaxTableRemoveEntry(*args):
  """gncTaxTableRemoveEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
  return _gnucash_core_c.gncTaxTableRemoveEntry(*args)

def gncTaxTableChanged(*args):
  """gncTaxTableChanged(GncTaxTable * table)"""
  return _gnucash_core_c.gncTaxTableChanged(*args)

def gncTaxTableBeginEdit(*args):
  """gncTaxTableBeginEdit(GncTaxTable * table)"""
  return _gnucash_core_c.gncTaxTableBeginEdit(*args)

def gncTaxTableCommitEdit(*args):
  """gncTaxTableCommitEdit(GncTaxTable * table)"""
  return _gnucash_core_c.gncTaxTableCommitEdit(*args)

def gncTaxTableEqual(*args):
  """gncTaxTableEqual(GncTaxTable const * a, GncTaxTable const * b) -> gboolean"""
  return _gnucash_core_c.gncTaxTableEqual(*args)

def gncTaxTableLookup(*args):
  """gncTaxTableLookup(QofBook const * book, GncGUID guid) -> GncTaxTable *"""
  return _gnucash_core_c.gncTaxTableLookup(*args)

def gncTaxTableLookupByName(*args):
  """gncTaxTableLookupByName(QofBook * book, char const * name) -> GncTaxTable *"""
  return _gnucash_core_c.gncTaxTableLookupByName(*args)

def gncTaxTableGetTables(*args):
  """gncTaxTableGetTables(QofBook * book) -> GList *"""
  return _gnucash_core_c.gncTaxTableGetTables(*args)

def gncTaxTableGetName(*args):
  """gncTaxTableGetName(GncTaxTable const * table) -> char const *"""
  return _gnucash_core_c.gncTaxTableGetName(*args)

def gncTaxTableGetParent(*args):
  """gncTaxTableGetParent(GncTaxTable const * table) -> GncTaxTable *"""
  return _gnucash_core_c.gncTaxTableGetParent(*args)

def gncTaxTableReturnChild(*args):
  """gncTaxTableReturnChild(GncTaxTable * table, gboolean make_new) -> GncTaxTable *"""
  return _gnucash_core_c.gncTaxTableReturnChild(*args)

def gncTaxTableGetEntries(*args):
  """gncTaxTableGetEntries(GncTaxTable const * table) -> GncTaxTableEntryList *"""
  return _gnucash_core_c.gncTaxTableGetEntries(*args)

def gncTaxTableGetRefcount(*args):
  """gncTaxTableGetRefcount(GncTaxTable const * table) -> gint64"""
  return _gnucash_core_c.gncTaxTableGetRefcount(*args)

def gncTaxTableLastModified(*args):
  """gncTaxTableLastModified(GncTaxTable const * table) -> Timespec"""
  return _gnucash_core_c.gncTaxTableLastModified(*args)

def gncTaxTableEntryGetAccount(*args):
  """gncTaxTableEntryGetAccount(GncTaxTableEntry const * entry) -> Account *"""
  return _gnucash_core_c.gncTaxTableEntryGetAccount(*args)

def gncTaxTableEntryGetType(*args):
  """gncTaxTableEntryGetType(GncTaxTableEntry const * entry) -> GncAmountType"""
  return _gnucash_core_c.gncTaxTableEntryGetType(*args)

def gncTaxTableEntryGetAmount(*args):
  """gncTaxTableEntryGetAmount(GncTaxTableEntry const * entry) -> _gnc_numeric"""
  return _gnucash_core_c.gncTaxTableEntryGetAmount(*args)

def gncTaxTableCompare(*args):
  """gncTaxTableCompare(GncTaxTable const * a, GncTaxTable const * b) -> int"""
  return _gnucash_core_c.gncTaxTableCompare(*args)

def gncTaxTableEntryCompare(*args):
  """gncTaxTableEntryCompare(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> int"""
  return _gnucash_core_c.gncTaxTableEntryCompare(*args)

def gncTaxTableEntryEqual(*args):
  """gncTaxTableEntryEqual(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> gboolean"""
  return _gnucash_core_c.gncTaxTableEntryEqual(*args)
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: 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(*args):
  """gncAccountValueAdd(GList * list, Account * acc, _gnc_numeric value) -> GList *"""
  return _gnucash_core_c.gncAccountValueAdd(*args)

def gncAccountValueAddList(*args):
  """gncAccountValueAddList(GList * l1, GList * l2) -> GList *"""
  return _gnucash_core_c.gncAccountValueAddList(*args)

def gncAccountValueTotal(*args):
  """gncAccountValueTotal(GList * list) -> _gnc_numeric"""
  return _gnucash_core_c.gncAccountValueTotal(*args)

def gncAccountValueDestroy(*args):
  """gncAccountValueDestroy(GList * list)"""
  return _gnucash_core_c.gncAccountValueDestroy(*args)
GNC_TT_NAME = _gnucash_core_c.GNC_TT_NAME
GNC_TT_REFCOUNT = _gnucash_core_c.GNC_TT_REFCOUNT

def gnc_search_customer_on_id(*args):
  """gnc_search_customer_on_id(QofBook * book, gchar const * id) -> GncCustomer *"""
  return _gnucash_core_c.gnc_search_customer_on_id(*args)

def gnc_search_invoice_on_id(*args):
  """gnc_search_invoice_on_id(QofBook * book, gchar const * id) -> GncInvoice *"""
  return _gnucash_core_c.gnc_search_invoice_on_id(*args)

def gnc_search_bill_on_id(*args):
  """gnc_search_bill_on_id(QofBook * book, gchar const * id) -> GncInvoice *"""
  return _gnucash_core_c.gnc_search_bill_on_id(*args)

def gnc_search_vendor_on_id(*args):
  """gnc_search_vendor_on_id(QofBook * book, gchar const * id) -> GncVendor *"""
  return _gnucash_core_c.gnc_search_vendor_on_id(*args)

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

def gnc_pricedb_get_type():
  """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_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(*args):
  """gnc_price_create(QofBook * book) -> GNCPrice *"""
  return _gnucash_core_c.gnc_price_create(*args)

def gnc_price_clone(*args):
  """gnc_price_clone(GNCPrice * p, QofBook * book) -> GNCPrice *"""
  return _gnucash_core_c.gnc_price_clone(*args)

def gnc_price_ref(*args):
  """gnc_price_ref(GNCPrice * p)"""
  return _gnucash_core_c.gnc_price_ref(*args)

def gnc_price_unref(*args):
  """gnc_price_unref(GNCPrice * p)"""
  return _gnucash_core_c.gnc_price_unref(*args)

def gnc_price_begin_edit(*args):
  """gnc_price_begin_edit(GNCPrice * p)"""
  return _gnucash_core_c.gnc_price_begin_edit(*args)

def gnc_price_commit_edit(*args):
  """gnc_price_commit_edit(GNCPrice * p)"""
  return _gnucash_core_c.gnc_price_commit_edit(*args)

def gnc_price_set_commodity(*args):
  """gnc_price_set_commodity(GNCPrice * p, gnc_commodity * c)"""
  return _gnucash_core_c.gnc_price_set_commodity(*args)

def gnc_price_set_currency(*args):
  """gnc_price_set_currency(GNCPrice * p, gnc_commodity * c)"""
  return _gnucash_core_c.gnc_price_set_currency(*args)

def gnc_price_set_time(*args):
  """gnc_price_set_time(GNCPrice * p, Timespec t)"""
  return _gnucash_core_c.gnc_price_set_time(*args)

def gnc_price_set_source(*args):
  """gnc_price_set_source(GNCPrice * p, PriceSource source)"""
  return _gnucash_core_c.gnc_price_set_source(*args)

def gnc_price_set_source_string(*args):
  """gnc_price_set_source_string(GNCPrice * p, char const * s)"""
  return _gnucash_core_c.gnc_price_set_source_string(*args)

def gnc_price_set_typestr(*args):
  """gnc_price_set_typestr(GNCPrice * p, char const * type)"""
  return _gnucash_core_c.gnc_price_set_typestr(*args)

def gnc_price_set_value(*args):
  """gnc_price_set_value(GNCPrice * p, _gnc_numeric value)"""
  return _gnucash_core_c.gnc_price_set_value(*args)

def gnc_price_lookup(*args):
  """gnc_price_lookup(GncGUID guid, QofBook * book) -> GNCPrice *"""
  return _gnucash_core_c.gnc_price_lookup(*args)

def gnc_price_get_commodity(*args):
  """gnc_price_get_commodity(GNCPrice const * p) -> gnc_commodity *"""
  return _gnucash_core_c.gnc_price_get_commodity(*args)

def gnc_price_get_currency(*args):
  """gnc_price_get_currency(GNCPrice const * p) -> gnc_commodity *"""
  return _gnucash_core_c.gnc_price_get_currency(*args)

def gnc_price_get_time(*args):
  """gnc_price_get_time(GNCPrice const * p) -> Timespec"""
  return _gnucash_core_c.gnc_price_get_time(*args)

def gnc_price_get_source(*args):
  """gnc_price_get_source(GNCPrice const * p) -> PriceSource"""
  return _gnucash_core_c.gnc_price_get_source(*args)

def gnc_price_get_source_string(*args):
  """gnc_price_get_source_string(GNCPrice const * p) -> char const *"""
  return _gnucash_core_c.gnc_price_get_source_string(*args)

def gnc_price_get_typestr(*args):
  """gnc_price_get_typestr(GNCPrice const * p) -> char const *"""
  return _gnucash_core_c.gnc_price_get_typestr(*args)

def gnc_price_get_value(*args):
  """gnc_price_get_value(GNCPrice const * p) -> _gnc_numeric"""
  return _gnucash_core_c.gnc_price_get_value(*args)

def gnc_price_equal(*args):
  """gnc_price_equal(GNCPrice const * p1, GNCPrice const * p2) -> gboolean"""
  return _gnucash_core_c.gnc_price_equal(*args)

def gnc_price_print(*args):
  """gnc_price_print(GNCPrice * db, FILE * f, int indent)"""
  return _gnucash_core_c.gnc_price_print(*args)
CURRENCY_DENOM = _gnucash_core_c.CURRENCY_DENOM
COMMODITY_DENOM_MULT = _gnucash_core_c.COMMODITY_DENOM_MULT

def gnc_price_list_insert(*args):
  """gnc_price_list_insert(PriceList ** prices, GNCPrice * p, gboolean check_dupl) -> gboolean"""
  return _gnucash_core_c.gnc_price_list_insert(*args)

def gnc_price_list_remove(*args):
  """gnc_price_list_remove(PriceList ** prices, GNCPrice * p) -> gboolean"""
  return _gnucash_core_c.gnc_price_list_remove(*args)

def gnc_price_list_destroy(*args):
  """gnc_price_list_destroy(PriceList * prices)"""
  return _gnucash_core_c.gnc_price_list_destroy(*args)

def gnc_price_list_equal(*args):
  """gnc_price_list_equal(PriceList * prices1, PriceList * prices2) -> gboolean"""
  return _gnucash_core_c.gnc_price_list_equal(*args)

def gnc_pricedb_get_db(*args):
  """gnc_pricedb_get_db(QofBook * book) -> GNCPriceDB *"""
  return _gnucash_core_c.gnc_pricedb_get_db(*args)

def gnc_collection_get_pricedb(*args):
  """gnc_collection_get_pricedb(QofCollection * col) -> GNCPriceDB *"""
  return _gnucash_core_c.gnc_collection_get_pricedb(*args)

def gnc_pricedb_destroy(*args):
  """gnc_pricedb_destroy(GNCPriceDB * db)"""
  return _gnucash_core_c.gnc_pricedb_destroy(*args)

def gnc_pricedb_begin_edit(*args):
  """gnc_pricedb_begin_edit(GNCPriceDB * arg1)"""
  return _gnucash_core_c.gnc_pricedb_begin_edit(*args)

def gnc_pricedb_commit_edit(*args):
  """gnc_pricedb_commit_edit(GNCPriceDB * arg1)"""
  return _gnucash_core_c.gnc_pricedb_commit_edit(*args)

def gnc_pricedb_set_bulk_update(*args):
  """gnc_pricedb_set_bulk_update(GNCPriceDB * db, gboolean bulk_update)"""
  return _gnucash_core_c.gnc_pricedb_set_bulk_update(*args)

def gnc_pricedb_add_price(*args):
  """gnc_pricedb_add_price(GNCPriceDB * db, GNCPrice * p) -> gboolean"""
  return _gnucash_core_c.gnc_pricedb_add_price(*args)

def gnc_pricedb_remove_price(*args):
  """gnc_pricedb_remove_price(GNCPriceDB * db, GNCPrice * p) -> gboolean"""
  return _gnucash_core_c.gnc_pricedb_remove_price(*args)

def gnc_pricedb_remove_old_prices(*args):
  """gnc_pricedb_remove_old_prices(GNCPriceDB * db, Timespec cutoff, gboolean const delete_user, gboolean delete_last) -> gboolean"""
  return _gnucash_core_c.gnc_pricedb_remove_old_prices(*args)

def gnc_pricedb_lookup_latest(*args):
  """gnc_pricedb_lookup_latest(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> GNCPrice *"""
  return _gnucash_core_c.gnc_pricedb_lookup_latest(*args)

def gnc_pricedb_lookup_latest_any_currency(*args):
  """gnc_pricedb_lookup_latest_any_currency(GNCPriceDB * db, gnc_commodity const * commodity) -> PriceList *"""
  return _gnucash_core_c.gnc_pricedb_lookup_latest_any_currency(*args)

def gnc_pricedb_has_prices(*args):
  """gnc_pricedb_has_prices(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> gboolean"""
  return _gnucash_core_c.gnc_pricedb_has_prices(*args)

def gnc_pricedb_get_prices(*args):
  """gnc_pricedb_get_prices(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> PriceList *"""
  return _gnucash_core_c.gnc_pricedb_get_prices(*args)

def gnc_pricedb_lookup_at_time(*args):
  """
    gnc_pricedb_lookup_at_time(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency, 
        Timespec t) -> PriceList *
    """
  return _gnucash_core_c.gnc_pricedb_lookup_at_time(*args)

def gnc_pricedb_lookup_day(*args):
  """
    gnc_pricedb_lookup_day(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency, 
        Timespec t) -> GNCPrice *
    """
  return _gnucash_core_c.gnc_pricedb_lookup_day(*args)

def gnc_pricedb_lookup_nearest_in_time(*args):
  """gnc_pricedb_lookup_nearest_in_time(GNCPriceDB * db, gnc_commodity const * c, gnc_commodity const * currency, Timespec t) -> GNCPrice *"""
  return _gnucash_core_c.gnc_pricedb_lookup_nearest_in_time(*args)

def gnc_pricedb_lookup_nearest_in_time_any_currency(*args):
  """gnc_pricedb_lookup_nearest_in_time_any_currency(GNCPriceDB * db, gnc_commodity const * c, Timespec t) -> PriceList *"""
  return _gnucash_core_c.gnc_pricedb_lookup_nearest_in_time_any_currency(*args)

def gnc_pricedb_lookup_latest_before(*args):
  """gnc_pricedb_lookup_latest_before(GNCPriceDB * db, gnc_commodity * c, gnc_commodity * currency, Timespec t) -> GNCPrice *"""
  return _gnucash_core_c.gnc_pricedb_lookup_latest_before(*args)

def gnc_pricedb_lookup_latest_before_any_currency(*args):
  """gnc_pricedb_lookup_latest_before_any_currency(GNCPriceDB * db, gnc_commodity * c, Timespec t) -> PriceList *"""
  return _gnucash_core_c.gnc_pricedb_lookup_latest_before_any_currency(*args)

def gnc_pricedb_convert_balance_latest_price(*args):
  """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(*args)

def gnc_pricedb_convert_balance_nearest_price(*args):
  """
    gnc_pricedb_convert_balance_nearest_price(GNCPriceDB * pdb, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency, 
        Timespec t) -> _gnc_numeric
    """
  return _gnucash_core_c.gnc_pricedb_convert_balance_nearest_price(*args)

def gnc_pricedb_foreach_price(*args):
  """gnc_pricedb_foreach_price(GNCPriceDB * db, gboolean (*)(GNCPrice *,gpointer) f, gpointer user_data, gboolean stable_order) -> gboolean"""
  return _gnucash_core_c.gnc_pricedb_foreach_price(*args)

def gnc_pricedb_get_num_prices(*args):
  """gnc_pricedb_get_num_prices(GNCPriceDB * db) -> guint"""
  return _gnucash_core_c.gnc_pricedb_get_num_prices(*args)

def gnc_pricedb_equal(*args):
  """gnc_pricedb_equal(GNCPriceDB * db1, GNCPriceDB * db2) -> gboolean"""
  return _gnucash_core_c.gnc_pricedb_equal(*args)

def gnc_pricedb_print_contents(*args):
  """gnc_pricedb_print_contents(GNCPriceDB * db, FILE * f)"""
  return _gnucash_core_c.gnc_pricedb_print_contents(*args)
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(*args):
  """xaccSplitGetCapGains(Split * arg1) -> _gnc_numeric"""
  return _gnucash_core_c.xaccSplitGetCapGains(*args)

def xaccAccountHasTrades(*args):
  """xaccAccountHasTrades(Account const * arg1) -> gboolean"""
  return _gnucash_core_c.xaccAccountHasTrades(*args)

def xaccAccountFindEarliestOpenLot(*args):
  """xaccAccountFindEarliestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
  return _gnucash_core_c.xaccAccountFindEarliestOpenLot(*args)

def xaccAccountFindLatestOpenLot(*args):
  """xaccAccountFindLatestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
  return _gnucash_core_c.xaccAccountFindLatestOpenLot(*args)

def xaccAccountGetDefaultGainAccount(*args):
  """xaccAccountGetDefaultGainAccount(Account const * acc, gnc_commodity const * currency) -> Account *"""
  return _gnucash_core_c.xaccAccountGetDefaultGainAccount(*args)

def xaccAccountSetDefaultGainAccount(*args):
  """xaccAccountSetDefaultGainAccount(Account * acc, Account const * gains_acct)"""
  return _gnucash_core_c.xaccAccountSetDefaultGainAccount(*args)

def xaccSplitGetCapGainsSplit(*args):
  """xaccSplitGetCapGainsSplit(Split const * arg1) -> Split *"""
  return _gnucash_core_c.xaccSplitGetCapGainsSplit(*args)

def xaccSplitGetGainsSourceSplit(*args):
  """xaccSplitGetGainsSourceSplit(Split const * arg1) -> Split *"""
  return _gnucash_core_c.xaccSplitGetGainsSourceSplit(*args)

def xaccSplitAssign(*args):
  """xaccSplitAssign(Split * split) -> gboolean"""
  return _gnucash_core_c.xaccSplitAssign(*args)

def xaccSplitAssignToLot(*args):
  """xaccSplitAssignToLot(Split * split, GNCLot * lot) -> Split *"""
  return _gnucash_core_c.xaccSplitAssignToLot(*args)

def xaccSplitComputeCapGains(*args):
  """xaccSplitComputeCapGains(Split * split, Account * gain_acc)"""
  return _gnucash_core_c.xaccSplitComputeCapGains(*args)

def xaccLotComputeCapGains(*args):
  """xaccLotComputeCapGains(GNCLot * lot, Account * gain_acc)"""
  return _gnucash_core_c.xaccLotComputeCapGains(*args)

def xaccScrubLot(*args):
  """xaccScrubLot(GNCLot * lot) -> gboolean"""
  return _gnucash_core_c.xaccScrubLot(*args)

def xaccAccountScrubLots(*args):
  """xaccAccountScrubLots(Account * acc)"""
  return _gnucash_core_c.xaccAccountScrubLots(*args)

def xaccAccountTreeScrubLots(*args):
  """xaccAccountTreeScrubLots(Account * acc)"""
  return _gnucash_core_c.xaccAccountTreeScrubLots(*args)
# This file is compatible with both classic and new-style classes.


