# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

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) or hasattr(self,name):
        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)"""
  return _gnucash_core_c.gncSplitGetGUID(*args)

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

def gncAccountGetGUID(*args):
  """gncAccountGetGUID(Account x)"""
  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 split, Account 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 xaccSplitGetBook(*args):
  """xaccSplitGetBook(Split split) -> QofBook"""
  return _gnucash_core_c.xaccSplitGetBook(*args)

def xaccSplitGetAccount(*args):
  """xaccSplitGetAccount(Split 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 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 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 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 memo)"""
  return _gnucash_core_c.xaccSplitSetMemo(*args)

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

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

def xaccSplitGetAction(*args):
  """xaccSplitGetAction(Split split) -> char"""
  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 split) -> char"""
  return _gnucash_core_c.xaccSplitGetReconcile(*args)

def xaccSplitSetDateReconciledSecs(*args):
  """xaccSplitSetDateReconciledSecs(Split split, time_t 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 split, Timespec ts)"""
  return _gnucash_core_c.xaccSplitGetDateReconciledTS(*args)

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

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

def xaccSplitGetAmount(*args):
  """xaccSplitGetAmount(Split 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 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 split) -> gnc_numeric"""
  return _gnucash_core_c.xaccSplitGetSharePrice(*args)

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

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

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

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

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

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

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

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

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

def xaccIsPeerSplit(*args):
  """xaccIsPeerSplit(Split split_1, Split split_2) -> gboolean"""
  return _gnucash_core_c.xaccIsPeerSplit(*args)

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

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

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

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

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

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

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

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

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

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

def xaccSplitGetCorrAccountCode(*args):
  """xaccSplitGetCorrAccountCode(Split sa) -> char"""
  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 split) -> gnc_numeric"""
  return _gnucash_core_c.xaccSplitVoidFormerAmount(*args)

def xaccSplitVoidFormerValue(*args):
  """xaccSplitVoidFormerValue(Split 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 account) -> AccountList"""
  return _gnucash_core_c.gnc_account_get_children(*args)

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

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

def gnc_account_get_descendants_sorted(*args):
  """gnc_account_get_descendants_sorted(Account 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__(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

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 source, QofBook book) -> Account"""
  return _gnucash_core_c.xaccCloneAccount(*args)

def xaccCloneAccountSimple(*args):
  """xaccCloneAccountSimple(Account source, QofBook book) -> Account"""
  return _gnucash_core_c.xaccCloneAccountSimple(*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 a, Account b, gboolean check_guids) -> gboolean"""
  return _gnucash_core_c.xaccAccountEqual(*args)

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

def gnc_get_account_separator_string():
  """gnc_get_account_separator_string() -> gchar"""
  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 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( guid, QofBook book) -> Account"""
  return _gnucash_core_c.xaccAccountLookup(*args)

def gnc_account_name_violations_errmsg(*args):
  """gnc_account_name_violations_errmsg(gchar 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 separator) -> GList"""
  return _gnucash_core_c.gnc_account_list_name_violations(*args)

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

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

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

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

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

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

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

def xaccAccountSetLastNum(*args):
  """xaccAccountSetLastNum(Account account, char 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 account) -> GNCAccountType"""
  return _gnucash_core_c.xaccAccountGetType(*args)

def xaccAccountIsPriced(*args):
  """xaccAccountIsPriced(Account 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_find_split(*args):
  """gnc_account_find_split(Account acc, Split s) -> gboolean"""
  return _gnucash_core_c.gnc_account_find_split(*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 account) -> char"""
  return _gnucash_core_c.xaccAccountGetName(*args)

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

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

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

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

def xaccAccountGetLastNum(*args):
  """xaccAccountGetLastNum(Account account) -> char"""
  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 gnc_account_get_start_balance(*args):
  """gnc_account_get_start_balance(Account acc) -> gnc_numeric"""
  return _gnucash_core_c.gnc_account_get_start_balance(*args)

def gnc_account_get_start_cleared_balance(*args):
  """gnc_account_get_start_cleared_balance(Account acc) -> gnc_numeric"""
  return _gnucash_core_c.gnc_account_get_start_cleared_balance(*args)

def gnc_account_get_start_reconciled_balance(*args):
  """gnc_account_get_start_reconciled_balance(Account acc) -> gnc_numeric"""
  return _gnucash_core_c.gnc_account_get_start_reconciled_balance(*args)

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

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

def xaccAccountRecomputeBalance(*args):
  """xaccAccountRecomputeBalance(Account arg0)"""
  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 account) -> gchar"""
  return _gnucash_core_c.gnc_account_get_full_name(*args)

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

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

def xaccAccountGetAutoInterestXfer(*args):
  """xaccAccountGetAutoInterestXfer(Account 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 account) -> gnc_commodity"""
  return _gnucash_core_c.xaccAccountGetCommodity(*args)

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

def xaccAccountGetCommoditySCUi(*args):
  """xaccAccountGetCommoditySCUi(Account 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 account) -> gboolean"""
  return _gnucash_core_c.xaccAccountGetNonStdSCU(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def xaccAccountGetBalanceChangeForPeriod(*args):
  """xaccAccountGetBalanceChangeForPeriod(Account acc, time_t date1, time_t 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 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 account) -> gboolean"""
  return _gnucash_core_c.gnc_account_is_root(*args)

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

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

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

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

def gnc_account_get_current_depth(*args):
  """gnc_account_get_current_depth(Account 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 account) -> gint"""
  return _gnucash_core_c.gnc_account_get_tree_depth(*args)

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

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

def gnc_account_foreach_descendant(*args):
  """gnc_account_foreach_descendant(Account 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 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_copy_children(*args):
  """gnc_account_copy_children(Account dest, Account src)"""
  return _gnucash_core_c.gnc_account_copy_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 account) -> gboolean"""
  return _gnucash_core_c.xaccAccountGetReconcileChildrenStatus(*args)

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

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

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

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

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

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

def xaccAccountGetTypeFromStr(*args):
  """xaccAccountGetTypeFromStr(gchar str) -> GNCAccountType"""
  return _gnucash_core_c.xaccAccountGetTypeFromStr(*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 xaccAccountGetSplitList(*args):
  """xaccAccountGetSplitList(Account 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 account, TransactionCallback proc, void data) -> gint"""
  return _gnucash_core_c.xaccAccountForEachTransaction(*args)

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

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

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

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

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

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

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

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

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

def xaccAccountGetReconcileLastInterval(*args):
  """xaccAccountGetReconcileLastInterval(Account 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 account, time_t postpone_date) -> gboolean"""
  return _gnucash_core_c.xaccAccountGetReconcilePostponeDate(*args)

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

def xaccAccountGetReconcilePostponeBalance(*args):
  """xaccAccountGetReconcilePostponeBalance(Account 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 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 account) -> GNCPlaceholderType"""
  return _gnucash_core_c.xaccAccountGetDescendantPlaceholder(*args)

def xaccAccountGetHidden(*args):
  """xaccAccountGetHidden(Account 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 acc) -> gboolean"""
  return _gnucash_core_c.xaccAccountIsHidden(*args)

def xaccAccountGetTaxRelated(*args):
  """xaccAccountGetTaxRelated(Account 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 account) -> char"""
  return _gnucash_core_c.xaccAccountGetTaxUSCode(*args)

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

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

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

def xaccAccountGetTaxUSCopyNumber(*args):
  """xaccAccountGetTaxUSCopyNumber(Account 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 xaccAccountGetMark(*args):
  """xaccAccountGetMark(Account account) -> short"""
  return _gnucash_core_c.xaccAccountGetMark(*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 account)"""
  return _gnucash_core_c.xaccAccountBeginStagedTransactionTraversals(*args)

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

def xaccSplitTransactionTraverse(*args):
  """xaccSplitTransactionTraverse(Split split, int stage) -> gboolean"""
  return _gnucash_core_c.xaccSplitTransactionTraverse(*args)

def xaccAccountStagedTransactionTraversal(*args):
  """
    xaccAccountStagedTransactionTraversal(Account 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 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 account) -> gnc_commodity"""
  return _gnucash_core_c.DxaccAccountGetCurrency(*args)

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

def dxaccAccountGetQuoteTZ(*args):
  """dxaccAccountGetQuoteTZ(Account account) -> char"""
  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_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

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 t) -> Transaction"""
  return _gnucash_core_c.xaccTransClone(*args)

def xaccTransEqual(*args):
  """
    xaccTransEqual(Transaction ta, Transaction 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 trans) -> gboolean"""
  return _gnucash_core_c.xaccTransIsOpen(*args)

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

def xaccTransFindSplitByAccount(*args):
  """xaccTransFindSplitByAccount(Transaction trans, Account 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 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 trans) -> char"""
  return _gnucash_core_c.xaccTransGetTxnType(*args)

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

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

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

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

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

def xaccTransGetNotes(*args):
  """xaccTransGetNotes(Transaction trans) -> char"""
  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 trans) -> gboolean"""
  return _gnucash_core_c.xaccTransGetIsClosingTxn(*args)

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

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

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

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

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

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

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

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

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

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

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

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

def xaccTransGetCurrency(*args):
  """xaccTransGetCurrency(Transaction 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 trans) -> gnc_numeric"""
  return _gnucash_core_c.xaccTransGetImbalanceValue(*args)

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

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

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

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

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

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

def xaccTransOrder(*args):
  """xaccTransOrder(Transaction ta, Transaction tb) -> int"""
  return _gnucash_core_c.xaccTransOrder(*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, time_t time)"""
  return _gnucash_core_c.xaccTransSetDatePostedSecs(*args)

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

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

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

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

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

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

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

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

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

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

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

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

def xaccTransVoid(*args):
  """xaccTransVoid(Transaction transaction, char 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 trans) -> Transaction"""
  return _gnucash_core_c.xaccTransGetReversedBy(*args)

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

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

def xaccTransGetVoidTime(*args):
  """xaccTransGetVoidTime(Transaction 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_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__(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 arg0) -> GNCLot"""
  return _gnucash_core_c.gnc_lot_new(*args)

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

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

def gnc_lot_get_book(*args):
  """gnc_lot_get_book(GNCLot arg0) -> 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 arg0, Split arg1)"""
  return _gnucash_core_c.gnc_lot_add_split(*args)

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

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

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

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

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

def gnc_lot_get_balance(*args):
  """gnc_lot_get_balance(GNCLot arg0) -> gnc_numeric"""
  return _gnucash_core_c.gnc_lot_get_balance(*args)

def gnc_lot_get_balance_before(*args):
  """gnc_lot_get_balance_before(GNCLot arg0, Split arg1, gnc_numeric arg2, gnc_numeric arg3)"""
  return _gnucash_core_c.gnc_lot_get_balance_before(*args)

def gnc_lot_is_closed(*args):
  """gnc_lot_is_closed(GNCLot arg0) -> 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 arg0)"""
  return _gnucash_core_c.gnc_lot_set_closed_unknown(*args)

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

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

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

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

def gnc_lot_get_marker(*args):
  """gnc_lot_get_marker(GNCLot arg0) -> unsigned char"""
  return _gnucash_core_c.gnc_lot_get_marker(*args)

def gnc_lot_set_marker(*args):
  """gnc_lot_set_marker(GNCLot arg0, unsigned char arg1)"""
  return _gnucash_core_c.gnc_lot_set_marker(*args)

def gnc_lot_get_slots(*args):
  """gnc_lot_get_slots(GNCLot arg0) -> 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 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 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)
class QofBackendOption(_object):
    """Proxy of C QofBackendOption struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QofBackendOption, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QofBackendOption, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _gnucash_core_c.QofBackendOption_type_set
    __swig_getmethods__["type"] = _gnucash_core_c.QofBackendOption_type_get
    if _newclass:type = _swig_property(_gnucash_core_c.QofBackendOption_type_get, _gnucash_core_c.QofBackendOption_type_set)
    __swig_setmethods__["option_name"] = _gnucash_core_c.QofBackendOption_option_name_set
    __swig_getmethods__["option_name"] = _gnucash_core_c.QofBackendOption_option_name_get
    if _newclass:option_name = _swig_property(_gnucash_core_c.QofBackendOption_option_name_get, _gnucash_core_c.QofBackendOption_option_name_set)
    __swig_setmethods__["description"] = _gnucash_core_c.QofBackendOption_description_set
    __swig_getmethods__["description"] = _gnucash_core_c.QofBackendOption_description_get
    if _newclass:description = _swig_property(_gnucash_core_c.QofBackendOption_description_get, _gnucash_core_c.QofBackendOption_description_set)
    __swig_setmethods__["tooltip"] = _gnucash_core_c.QofBackendOption_tooltip_set
    __swig_getmethods__["tooltip"] = _gnucash_core_c.QofBackendOption_tooltip_get
    if _newclass:tooltip = _swig_property(_gnucash_core_c.QofBackendOption_tooltip_get, _gnucash_core_c.QofBackendOption_tooltip_set)
    __swig_setmethods__["value"] = _gnucash_core_c.QofBackendOption_value_set
    __swig_getmethods__["value"] = _gnucash_core_c.QofBackendOption_value_get
    if _newclass:value = _swig_property(_gnucash_core_c.QofBackendOption_value_get, _gnucash_core_c.QofBackendOption_value_set)
    def __init__(self): 
        """__init__(self) -> QofBackendOption"""
        this = _gnucash_core_c.new_QofBackendOption()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _gnucash_core_c.delete_QofBackendOption
    __del__ = lambda self : None;
QofBackendOption_swigregister = _gnucash_core_c.QofBackendOption_swigregister
QofBackendOption_swigregister(QofBackendOption)


def qof_backend_prepare_frame(*args):
  """qof_backend_prepare_frame(QofBackend be)"""
  return _gnucash_core_c.qof_backend_prepare_frame(*args)

def qof_backend_prepare_option(*args):
  """qof_backend_prepare_option(QofBackend be,  option)"""
  return _gnucash_core_c.qof_backend_prepare_option(*args)

def qof_backend_complete_frame(*args):
  """qof_backend_complete_frame(QofBackend be) -> KvpFrame"""
  return _gnucash_core_c.qof_backend_complete_frame(*args)

def qof_backend_option_foreach(*args):
  """qof_backend_option_foreach(KvpFrame config, QofBackendOptionCB cb, gpointer data)"""
  return _gnucash_core_c.qof_backend_option_foreach(*args)

def qof_backend_load_config(*args):
  """qof_backend_load_config(QofBackend be, KvpFrame config)"""
  return _gnucash_core_c.qof_backend_load_config(*args)

def qof_backend_get_config(*args):
  """qof_backend_get_config(QofBackend be) -> KvpFrame"""
  return _gnucash_core_c.qof_backend_get_config(*args)

def qof_load_backend_library(*args):
  """qof_load_backend_library(gchar directory, gchar 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 book) -> QofBackend"""
  return _gnucash_core_c.qof_book_get_backend(*args)

def qof_book_set_backend(*args):
  """qof_book_set_backend(QofBook book, QofBackend arg1)"""
  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 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 session) -> char"""
  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_add_book(*args):
  """qof_session_add_book(QofSession session, QofBook book)"""
  return _gnucash_core_c.qof_session_add_book(*args)

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

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

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

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

def qof_instance_copy_to_session(*args):
  """qof_instance_copy_to_session(QofSession new_session, QofInstance original) -> gboolean"""
  return _gnucash_core_c.qof_instance_copy_to_session(*args)

def qof_instance_copy_list(*args):
  """qof_instance_copy_list(QofSession new_session, GList entity_list) -> gboolean"""
  return _gnucash_core_c.qof_instance_copy_list(*args)

def qof_instance_copy_coll(*args):
  """qof_instance_copy_coll(QofSession new_session, QofCollection entity_coll) -> gboolean"""
  return _gnucash_core_c.qof_instance_copy_coll(*args)

def qof_instance_copy_coll_r(*args):
  """qof_instance_copy_coll_r(QofSession new_session, QofCollection coll) -> gboolean"""
  return _gnucash_core_c.qof_instance_copy_coll_r(*args)

def qof_instance_copy_one_r(*args):
  """qof_instance_copy_one_r(QofSession new_session, QofInstance ent) -> gboolean"""
  return _gnucash_core_c.qof_instance_copy_one_r(*args)
QOF_STDOUT = _gnucash_core_c.QOF_STDOUT

def qof_session_events_pending(*args):
  """qof_session_events_pending(QofSession 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 book) -> gboolean"""
  return _gnucash_core_c.qof_book_use_trading_accounts(*args)

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

def qof_book_session_not_saved(*args):
  """qof_book_session_not_saved(QofBook 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_get_alt_dirty_mode():
  """qof_get_alt_dirty_mode() -> gboolean"""
  return _gnucash_core_c.qof_get_alt_dirty_mode()

def qof_set_alt_dirty_mode(*args):
  """qof_set_alt_dirty_mode(gboolean enabled)"""
  return _gnucash_core_c.qof_set_alt_dirty_mode(*args)

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 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 arg0) -> QofIdType"""
  return _gnucash_core_c.qof_collection_get_type(*args)

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

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

def qof_collection_get_data(*args):
  """qof_collection_get_data(QofCollection 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 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_merge(*args):
  """qof_collection_merge(QofCollection target, QofCollection merge) -> gboolean"""
  return _gnucash_core_c.qof_collection_merge(*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 glist) -> QofCollection"""
  return _gnucash_core_c.qof_collection_from_glist(*args)
GUID_DATA_SIZE = _gnucash_core_c.GUID_DATA_SIZE
class GncGUID(_object):
    """Proxy of C GncGUID struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GncGUID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GncGUID, name)
    __repr__ = _swig_repr
    __swig_setmethods__["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__(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 value)"""
  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_init_with_salt(*args):
  """guid_init_with_salt(void salt, size_t salt_len)"""
  return _gnucash_core_c.guid_init_with_salt(*args)

def guid_init_only_salt(*args):
  """guid_init_only_salt(void salt, size_t salt_len)"""
  return _gnucash_core_c.guid_init_only_salt(*args)

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

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

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

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

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

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

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

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

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

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

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

def guid_compare(*args):
  """guid_compare( g1,  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__(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 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"""
  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_get_type():
  """gnc_numeric_get_type() -> GType"""
  return _gnucash_core_c.gnc_numeric_get_type()

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 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 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 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 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 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 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 source) -> char"""
  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 source) -> char"""
  return _gnucash_core_c.gnc_quote_source_get_internal_name(*args)

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

def gnc_commodity_new(*args):
  """
    gnc_commodity_new(QofBook book, char fullname, char commodity_namespace, 
        char mnemonic, char 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 src)"""
  return _gnucash_core_c.gnc_commodity_copy(*args)

def gnc_commodity_clone(*args):
  """gnc_commodity_clone(gnc_commodity 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 cm) -> char"""
  return _gnucash_core_c.gnc_commodity_get_mnemonic(*args)

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

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

def gnc_commodity_get_namespace_ds(*args):
  """gnc_commodity_get_namespace_ds(gnc_commodity 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 cm) -> char"""
  return _gnucash_core_c.gnc_commodity_get_fullname(*args)

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

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

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

def gnc_commodity_get_fraction(*args):
  """gnc_commodity_get_fraction(gnc_commodity 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 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 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 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 cm) -> char"""
  return _gnucash_core_c.gnc_commodity_get_quote_tz(*args)

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

def gnc_commodity_set_namespace(*args):
  """gnc_commodity_set_namespace(gnc_commodity cm, char 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 fullname)"""
  return _gnucash_core_c.gnc_commodity_set_fullname(*args)

def gnc_commodity_set_cusip(*args):
  """gnc_commodity_set_cusip(gnc_commodity cm, char 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 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 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 tz)"""
  return _gnucash_core_c.gnc_commodity_set_quote_tz(*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 a, gnc_commodity b) -> gboolean"""
  return _gnucash_core_c.gnc_commodity_equiv(*args)

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

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

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

def gnc_commodity_namespace_is_iso(*args):
  """gnc_commodity_namespace_is_iso(char 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 cm) -> gboolean"""
  return _gnucash_core_c.gnc_commodity_is_iso(*args)

def gnc_commodity_is_currency(*args):
  """gnc_commodity_is_currency(gnc_commodity 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_equal(*args):
  """gnc_commodity_table_equal(gnc_commodity_table t_1, gnc_commodity_table t_2) -> gboolean"""
  return _gnucash_core_c.gnc_commodity_table_equal(*args)

def gnc_commodity_table_copy(*args):
  """
    gnc_commodity_table_copy(gnc_commodity_table dest, gnc_commodity_table src, 
        QofBook dest_book)
    """
  return _gnucash_core_c.gnc_commodity_table_copy(*args)

def gnc_commodity_table_lookup(*args):
  """
    gnc_commodity_table_lookup(gnc_commodity_table table, char commodity_namespace, 
        char 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 table, char 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 t, char commodity_namespace, char 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( guid, QofBook book) -> gnc_commodity"""
  return _gnucash_core_c.gnc_commodity_find_commodity_by_guid(*args)

def gnc_commodity_find_namespace_by_guid(*args):
  """gnc_commodity_find_namespace_by_guid( guid, QofBook book) -> gnc_commodity_namespace"""
  return _gnucash_core_c.gnc_commodity_find_namespace_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 ns) -> char"""
  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 ns) -> GList"""
  return _gnucash_core_c.gnc_commodity_namespace_get_commodity_list(*args)

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

def gnc_commodity_table_has_namespace(*args):
  """gnc_commodity_table_has_namespace(gnc_commodity_table table, char 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 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 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 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 table, char 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 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 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 table, char 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 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 table, gboolean 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 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__(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 owner) -> QofIdTypeConst"""
  return _gnucash_core_c.qofOwnerGetType(*args)

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

def qofOwnerSetEntity(*args):
  """qofOwnerSetEntity(GncOwner owner, QofInstance ent)"""
  return _gnucash_core_c.qofOwnerSetEntity(*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 owner) -> GncOwnerType"""
  return _gnucash_core_c.gncOwnerGetType(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncOwnerGetSlots(*args):
  """gncOwnerGetSlots(GncOwner owner) -> KvpFrame"""
  return _gnucash_core_c.gncOwnerGetSlots(*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 gncOwnerCreate():
  """gncOwnerCreate() -> GncOwner"""
  return _gnucash_core_c.gncOwnerCreate()

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 id)"""
  return _gnucash_core_c.gncCustomerSetID(*args)

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

def gncCustomerSetNotes(*args):
  """gncCustomerSetNotes(GncCustomer customer, char 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 book,  guid) -> GncCustomer"""
  return _gnucash_core_c.gncCustomerLookup(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncEmployeeSetAcl(*args):
  """gncEmployeeSetAcl(GncEmployee employee, char 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 employee) -> char"""
  return _gnucash_core_c.gncEmployeeGetID(*args)

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

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

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

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

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

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

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

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

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

def gncEmployeeLookup(*args):
  """gncEmployeeLookup(QofBook book,  guid) -> GncEmployee"""
  return _gnucash_core_c.gncEmployeeLookup(*args)

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

def gncEmployeeEqual(*args):
  """gncEmployeeEqual(GncEmployee e1, GncEmployee e2) -> gboolean"""
  return _gnucash_core_c.gncEmployeeEqual(*args)
EMPLOYEE_ID = _gnucash_core_c.EMPLOYEE_ID
EMPLOYEE_USERNAME = _gnucash_core_c.EMPLOYEE_USERNAME
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
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 id)"""
  return _gnucash_core_c.gncVendorSetID(*args)

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

def gncVendorSetNotes(*args):
  """gncVendorSetNotes(GncVendor vendor, char 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 vendor) -> char"""
  return _gnucash_core_c.gncVendorGetID(*args)

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

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

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

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

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

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

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

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

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

def gncVendorGetJoblist(*args):
  """gncVendorGetJoblist(GncVendor vendor, gboolean show_all) -> GList"""
  return _gnucash_core_c.gncVendorGetJoblist(*args)

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

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

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

def gncVendorLookup(*args):
  """gncVendorLookup(QofBook book,  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
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 name)"""
  return _gnucash_core_c.gncAddressSetName(*args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncAddressEqual(*args):
  """gncAddressEqual(GncAddress a, GncAddress 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 name)"""
  return _gnucash_core_c.gncBillTermSetName(*args)

def gncBillTermSetDescription(*args):
  """gncBillTermSetDescription(GncBillTerm term, char 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 book,  guid) -> GncBillTerm"""
  return _gnucash_core_c.gncBillTermLookup(*args)

def gncBillTermLookupByName(*args):
  """gncBillTermLookupByName(QofBook book, char 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 term) -> char"""
  return _gnucash_core_c.gncBillTermGetName(*args)

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

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

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

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

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

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

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

def gncBillTermGetParent(*args):
  """gncBillTermGetParent(GncBillTerm 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 term) -> gint64"""
  return _gnucash_core_c.gncBillTermGetRefcount(*args)

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

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

def gncBillTermComputeDueDate(*args):
  """gncBillTermComputeDueDate(GncBillTerm term, Timespec post_date) -> Timespec"""
  return _gnucash_core_c.gncBillTermComputeDueDate(*args)

def gncBillTermComputeDiscountDate(*args):
  """gncBillTermComputeDiscountDate(GncBillTerm term, Timespec post_date) -> Timespec"""
  return _gnucash_core_c.gncBillTermComputeDiscountDate(*args)
GNC_ID_INVOICE = _gnucash_core_c.GNC_ID_INVOICE

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 other_invoice) -> GncInvoice"""
  return _gnucash_core_c.gncInvoiceCopy(*args)

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

def gncInvoiceSetOwner(*args):
  """gncInvoiceSetOwner(GncInvoice invoice, GncOwner owner)"""
  return _gnucash_core_c.gncInvoiceSetOwner(*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 billing_id)"""
  return _gnucash_core_c.gncInvoiceSetBillingID(*args)

def gncInvoiceSetNotes(*args):
  """gncInvoiceSetNotes(GncInvoice invoice, char 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 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 gncInvoiceRemovePrice(*args):
  """gncInvoiceRemovePrice(GncInvoice invoice, GNCPrice price)"""
  return _gnucash_core_c.gncInvoiceRemovePrice(*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 gncBillAddPrice(*args):
  """gncBillAddPrice(GncInvoice bill, GNCPrice price)"""
  return _gnucash_core_c.gncBillAddPrice(*args)

def gncBillRemovePrice(*args):
  """gncBillRemovePrice(GncInvoice bill, GNCPrice price)"""
  return _gnucash_core_c.gncBillRemovePrice(*args)

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

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

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

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

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

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

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

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

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

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

def gncInvoiceGetTypeFromOwnerType(*args):
  """gncInvoiceGetTypeFromOwnerType(GncOwnerType type) -> char"""
  return _gnucash_core_c.gncInvoiceGetTypeFromOwnerType(*args)

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

def gncInvoiceGetCurrency(*args):
  """gncInvoiceGetCurrency(GncInvoice 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 invoice) -> gnc_numeric"""
  return _gnucash_core_c.gncInvoiceGetToChargeAmount(*args)

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

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

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

def gncInvoiceGetPostedAcc(*args):
  """gncInvoiceGetPostedAcc(GncInvoice 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 gncInvoiceGetPrices(*args):
  """gncInvoiceGetPrices(GncInvoice invoice) -> GList"""
  return _gnucash_core_c.gncInvoiceGetPrices(*args)

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

def gncInvoicePostToAccount(*args):
  """
    gncInvoicePostToAccount(GncInvoice invoice, Account acc, Timespec posted_date, 
        Timespec due_date, char memo, gboolean accumulatesplits) -> 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 gncOwnerApplyPayment(*args):
  """
    gncOwnerApplyPayment(GncOwner owner, GncInvoice invoice, Account posted_acc, 
        Account xfer_acc, gnc_numeric amount, gnc_numeric exch, 
        Timespec date, char memo, char num) -> Transaction
    """
  return _gnucash_core_c.gncOwnerApplyPayment(*args)

def gncInvoiceGetInvoiceFromTxn(*args):
  """gncInvoiceGetInvoiceFromTxn(Transaction 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 book,  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 a, GncInvoice b) -> int"""
  return _gnucash_core_c.gncInvoiceCompare(*args)

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

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

def gncInvoiceIsPaid(*args):
  """gncInvoiceIsPaid(GncInvoice 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_TYPE = _gnucash_core_c.INVOICE_TYPE
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)
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 id)"""
  return _gnucash_core_c.gncJobSetID(*args)

def gncJobSetName(*args):
  """gncJobSetName(GncJob job, char jobname)"""
  return _gnucash_core_c.gncJobSetName(*args)

def gncJobSetReference(*args):
  """gncJobSetReference(GncJob job, char 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 job) -> char"""
  return _gnucash_core_c.gncJobGetID(*args)

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

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

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

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

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

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

def gncJobEqual(*args):
  """gncJobEqual(GncJob a, GncJob 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"""
  return _gnucash_core_c.gncEntryDiscountHowToString(*args)

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

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

def gncEntryPaymentStringToType(*args):
  """gncEntryPaymentStringToType(char 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 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 desc)"""
  return _gnucash_core_c.gncEntrySetDescription(*args)

def gncEntrySetAction(*args):
  """gncEntrySetAction(GncEntry entry, char action)"""
  return _gnucash_core_c.gncEntrySetAction(*args)

def gncEntrySetNotes(*args):
  """gncEntrySetNotes(GncEntry entry, char notes)"""
  return _gnucash_core_c.gncEntrySetNotes(*args)

def gncEntrySetQuantity(*args):
  """gncEntrySetQuantity(GncEntry entry, gnc_numeric quantity)"""
  return _gnucash_core_c.gncEntrySetQuantity(*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 type)"""
  return _gnucash_core_c.qofEntrySetInvDiscType(*args)

def qofEntrySetInvDiscHow(*args):
  """qofEntrySetInvDiscHow(GncEntry entry, char 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 gncEntryGetDate(*args):
  """gncEntryGetDate(GncEntry entry) -> Timespec"""
  return _gnucash_core_c.gncEntryGetDate(*args)

def gncEntryGetDateEntered(*args):
  """gncEntryGetDateEntered(GncEntry entry) -> Timespec"""
  return _gnucash_core_c.gncEntryGetDateEntered(*args)

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

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

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

def gncEntryGetQuantity(*args):
  """gncEntryGetQuantity(GncEntry entry) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryGetQuantity(*args)

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

def gncEntryGetInvPrice(*args):
  """gncEntryGetInvPrice(GncEntry entry) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryGetInvPrice(*args)

def gncEntryGetInvDiscount(*args):
  """gncEntryGetInvDiscount(GncEntry entry) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryGetInvDiscount(*args)

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

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

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

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

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

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

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

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

def gncEntryGetBillPrice(*args):
  """gncEntryGetBillPrice(GncEntry entry) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryGetBillPrice(*args)

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

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

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

def gncEntryGetBillable(*args):
  """gncEntryGetBillable(GncEntry 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 entry) -> GncEntryPaymentType"""
  return _gnucash_core_c.gncEntryGetBillPayment(*args)

def gncEntryCopy(*args):
  """gncEntryCopy(GncEntry src, GncEntry dest)"""
  return _gnucash_core_c.gncEntryCopy(*args)

def gncEntryReturnValue(*args):
  """gncEntryReturnValue(GncEntry entry, gboolean is_inv) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryReturnValue(*args)

def gncEntryReturnDiscountValue(*args):
  """gncEntryReturnDiscountValue(GncEntry entry, gboolean is_inv) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryReturnDiscountValue(*args)

def gncEntryReturnTaxValue(*args):
  """gncEntryReturnTaxValue(GncEntry entry, gboolean is_inv) -> gnc_numeric"""
  return _gnucash_core_c.gncEntryReturnTaxValue(*args)

def gncEntryReturnTaxValues(*args):
  """gncEntryReturnTaxValues(GncEntry entry, gboolean is_inv) -> AccountValueList"""
  return _gnucash_core_c.gncEntryReturnTaxValues(*args)

def gncEntryGetValue(*args):
  """
    gncEntryGetValue(GncEntry entry, gboolean is_inv, gnc_numeric value, 
        gnc_numeric discount, gnc_numeric tax_value, 
        GList tax_values)
    """
  return _gnucash_core_c.gncEntryGetValue(*args)

def gncEntryComputeValue(*args):
  """
    gncEntryComputeValue(gnc_numeric qty, gnc_numeric price, GncTaxTable 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 entry) -> GncOrder"""
  return _gnucash_core_c.gncEntryGetOrder(*args)

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

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

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

def gncEntryIsOpen(*args):
  """gncEntryIsOpen(GncEntry 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 a, GncEntry b) -> int"""
  return _gnucash_core_c.gncEntryCompare(*args)

def gncEntryEqual(*args):
  """gncEntryEqual(GncEntry a, GncEntry b) -> gboolean"""
  return _gnucash_core_c.gncEntryEqual(*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"""
  return _gnucash_core_c.gncAmountTypeToString(*args)

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

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

def gncTaxIncludedStringToType(*args):
  """gncTaxIncludedStringToType(char 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 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 a, GncTaxTable b) -> gboolean"""
  return _gnucash_core_c.gncTaxTableEqual(*args)

def gncTaxTableLookup(*args):
  """gncTaxTableLookup(QofBook book,  guid) -> GncTaxTable"""
  return _gnucash_core_c.gncTaxTableLookup(*args)

def gncTaxTableLookupByName(*args):
  """gncTaxTableLookupByName(QofBook book, char 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 table) -> char"""
  return _gnucash_core_c.gncTaxTableGetName(*args)

def gncTaxTableGetParent(*args):
  """gncTaxTableGetParent(GncTaxTable 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 table) -> GncTaxTableEntryList"""
  return _gnucash_core_c.gncTaxTableGetEntries(*args)

def gncTaxTableGetRefcount(*args):
  """gncTaxTableGetRefcount(GncTaxTable table) -> gint64"""
  return _gnucash_core_c.gncTaxTableGetRefcount(*args)

def gncTaxTableLastModified(*args):
  """gncTaxTableLastModified(GncTaxTable table) -> Timespec"""
  return _gnucash_core_c.gncTaxTableLastModified(*args)

def gncTaxTableEntryGetAccount(*args):
  """gncTaxTableEntryGetAccount(GncTaxTableEntry entry) -> Account"""
  return _gnucash_core_c.gncTaxTableEntryGetAccount(*args)

def gncTaxTableEntryGetType(*args):
  """gncTaxTableEntryGetType(GncTaxTableEntry entry) -> GncAmountType"""
  return _gnucash_core_c.gncTaxTableEntryGetType(*args)

def gncTaxTableEntryGetAmount(*args):
  """gncTaxTableEntryGetAmount(GncTaxTableEntry entry) -> gnc_numeric"""
  return _gnucash_core_c.gncTaxTableEntryGetAmount(*args)

def gncTaxTableCompare(*args):
  """gncTaxTableCompare(GncTaxTable a, GncTaxTable b) -> int"""
  return _gnucash_core_c.gncTaxTableCompare(*args)

def gncTaxTableEntryCompare(*args):
  """gncTaxTableEntryCompare(GncTaxTableEntry a, GncTaxTableEntry b) -> int"""
  return _gnucash_core_c.gncTaxTableEntryCompare(*args)

def gncTaxTableEntryEqual(*args):
  """gncTaxTableEntryEqual(GncTaxTableEntry a, GncTaxTableEntry 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__(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 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 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 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 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()

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, char source)"""
  return _gnucash_core_c.gnc_price_set_source(*args)

def gnc_price_set_typestr(*args):
  """gnc_price_set_typestr(GNCPrice p, char 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( guid, QofBook book) -> GNCPrice"""
  return _gnucash_core_c.gnc_price_lookup(*args)

def gnc_price_get_commodity(*args):
  """gnc_price_get_commodity(GNCPrice p) -> gnc_commodity"""
  return _gnucash_core_c.gnc_price_get_commodity(*args)

def gnc_price_get_currency(*args):
  """gnc_price_get_currency(GNCPrice p) -> gnc_commodity"""
  return _gnucash_core_c.gnc_price_get_currency(*args)

def gnc_price_get_time(*args):
  """gnc_price_get_time(GNCPrice p) -> Timespec"""
  return _gnucash_core_c.gnc_price_get_time(*args)

def gnc_price_get_source(*args):
  """gnc_price_get_source(GNCPrice p) -> char"""
  return _gnucash_core_c.gnc_price_get_source(*args)

def gnc_price_get_typestr(*args):
  """gnc_price_get_typestr(GNCPrice p) -> char"""
  return _gnucash_core_c.gnc_price_get_typestr(*args)

def gnc_price_get_value(*args):
  """gnc_price_get_value(GNCPrice p) -> gnc_numeric"""
  return _gnucash_core_c.gnc_price_get_value(*args)

def gnc_price_equal(*args):
  """gnc_price_equal(GNCPrice p1, GNCPrice 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)

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 arg0)"""
  return _gnucash_core_c.gnc_pricedb_begin_edit(*args)

def gnc_pricedb_commit_edit(*args):
  """gnc_pricedb_commit_edit(GNCPriceDB arg0)"""
  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 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 commodity, gnc_commodity 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 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 commodity, gnc_commodity 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 commodity, gnc_commodity 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 commodity, gnc_commodity currency, 
        Timespec t) -> PriceList
    """
  return _gnucash_core_c.gnc_pricedb_lookup_at_time(*args)

def gnc_pricedb_lookup_at_time_any_currency(*args):
  """gnc_pricedb_lookup_at_time_any_currency(GNCPriceDB db, gnc_commodity c, Timespec t) -> PriceList"""
  return _gnucash_core_c.gnc_pricedb_lookup_at_time_any_currency(*args)

def gnc_pricedb_lookup_day(*args):
  """
    gnc_pricedb_lookup_day(GNCPriceDB db, gnc_commodity commodity, gnc_commodity currency, 
        Timespec t) -> PriceList
    """
  return _gnucash_core_c.gnc_pricedb_lookup_day(*args)

def gnc_pricedb_lookup_day_any_currency(*args):
  """gnc_pricedb_lookup_day_any_currency(GNCPriceDB db, gnc_commodity c, Timespec t) -> PriceList"""
  return _gnucash_core_c.gnc_pricedb_lookup_day_any_currency(*args)

def gnc_pricedb_lookup_nearest_in_time(*args):
  """
    gnc_pricedb_lookup_nearest_in_time(GNCPriceDB db, gnc_commodity c, gnc_commodity 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 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 balance_currency, 
        gnc_commodity 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 balance_currency, 
        gnc_commodity new_currency, 
        Timespec t) -> gnc_numeric
    """
  return _gnucash_core_c.gnc_pricedb_convert_balance_nearest_price(*args)

def gnc_pricedb_convert_balance_latest_before(*args):
  """
    gnc_pricedb_convert_balance_latest_before(GNCPriceDB pdb, gnc_numeric balance, gnc_commodity balance_currency, 
        gnc_commodity new_currency, 
        Timespec t) -> gnc_numeric
    """
  return _gnucash_core_c.gnc_pricedb_convert_balance_latest_before(*args)

def gnc_pricedb_foreach_price(*args):
  """gnc_pricedb_foreach_price(GNCPriceDB db, gboolean 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


