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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _gnucash_core_c
else:
    import _gnucash_core_c

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


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



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

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

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

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

YREC = _gnucash_core_c.YREC

FREC = _gnucash_core_c.FREC

NREC = _gnucash_core_c.NREC

VREC = _gnucash_core_c.VREC


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SPLIT_BALANCE = _gnucash_core_c.SPLIT_BALANCE

SPLIT_CLEARED_BALANCE = _gnucash_core_c.SPLIT_CLEARED_BALANCE

SPLIT_RECONCILED_BALANCE = _gnucash_core_c.SPLIT_RECONCILED_BALANCE

SPLIT_MEMO = _gnucash_core_c.SPLIT_MEMO

SPLIT_ACTION = _gnucash_core_c.SPLIT_ACTION

SPLIT_RECONCILE = _gnucash_core_c.SPLIT_RECONCILE

SPLIT_AMOUNT = _gnucash_core_c.SPLIT_AMOUNT

SPLIT_SHARE_PRICE = _gnucash_core_c.SPLIT_SHARE_PRICE

SPLIT_VALUE = _gnucash_core_c.SPLIT_VALUE

SPLIT_TYPE = _gnucash_core_c.SPLIT_TYPE

SPLIT_VOIDED_AMOUNT = _gnucash_core_c.SPLIT_VOIDED_AMOUNT

SPLIT_VOIDED_VALUE = _gnucash_core_c.SPLIT_VOIDED_VALUE

SPLIT_LOT = _gnucash_core_c.SPLIT_LOT

SPLIT_TRANS = _gnucash_core_c.SPLIT_TRANS

SPLIT_ACCOUNT = _gnucash_core_c.SPLIT_ACCOUNT

SPLIT_ACCOUNT_GUID = _gnucash_core_c.SPLIT_ACCOUNT_GUID

SPLIT_ACCT_FULLNAME = _gnucash_core_c.SPLIT_ACCT_FULLNAME

SPLIT_CORR_ACCT_NAME = _gnucash_core_c.SPLIT_CORR_ACCT_NAME

SPLIT_CORR_ACCT_CODE = _gnucash_core_c.SPLIT_CORR_ACCT_CODE


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

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

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

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

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

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

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

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    acc = property(_gnucash_core_c.GncImportMatchMap_acc_get, _gnucash_core_c.GncImportMatchMap_acc_set, doc=r"""acc : p.Account""")
    book = property(_gnucash_core_c.GncImportMatchMap_book_get, _gnucash_core_c.GncImportMatchMap_book_set, doc=r"""book : p.QofBook""")

    def __init__(self):
        r"""__init__(GncImportMatchMap self) -> GncImportMatchMap"""
        _gnucash_core_c.GncImportMatchMap_swiginit(self, _gnucash_core_c.new_GncImportMatchMap())
    __swig_destroy__ = _gnucash_core_c.delete_GncImportMatchMap

# Register GncImportMatchMap in _gnucash_core_c:
_gnucash_core_c.GncImportMatchMap_swigregister(GncImportMatchMap)


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

ACCT_TYPE_NONE = _gnucash_core_c.ACCT_TYPE_NONE

ACCT_TYPE_BANK = _gnucash_core_c.ACCT_TYPE_BANK

ACCT_TYPE_CASH = _gnucash_core_c.ACCT_TYPE_CASH

ACCT_TYPE_CREDIT = _gnucash_core_c.ACCT_TYPE_CREDIT

ACCT_TYPE_ASSET = _gnucash_core_c.ACCT_TYPE_ASSET

ACCT_TYPE_LIABILITY = _gnucash_core_c.ACCT_TYPE_LIABILITY

ACCT_TYPE_STOCK = _gnucash_core_c.ACCT_TYPE_STOCK

ACCT_TYPE_MUTUAL = _gnucash_core_c.ACCT_TYPE_MUTUAL

ACCT_TYPE_CURRENCY = _gnucash_core_c.ACCT_TYPE_CURRENCY

ACCT_TYPE_INCOME = _gnucash_core_c.ACCT_TYPE_INCOME

ACCT_TYPE_EXPENSE = _gnucash_core_c.ACCT_TYPE_EXPENSE

ACCT_TYPE_EQUITY = _gnucash_core_c.ACCT_TYPE_EQUITY

ACCT_TYPE_RECEIVABLE = _gnucash_core_c.ACCT_TYPE_RECEIVABLE

ACCT_TYPE_PAYABLE = _gnucash_core_c.ACCT_TYPE_PAYABLE

ACCT_TYPE_ROOT = _gnucash_core_c.ACCT_TYPE_ROOT

ACCT_TYPE_TRADING = _gnucash_core_c.ACCT_TYPE_TRADING

NUM_ACCOUNT_TYPES = _gnucash_core_c.NUM_ACCOUNT_TYPES

ACCT_TYPE_CHECKING = _gnucash_core_c.ACCT_TYPE_CHECKING

ACCT_TYPE_SAVINGS = _gnucash_core_c.ACCT_TYPE_SAVINGS

ACCT_TYPE_MONEYMRKT = _gnucash_core_c.ACCT_TYPE_MONEYMRKT

ACCT_TYPE_CREDITLINE = _gnucash_core_c.ACCT_TYPE_CREDITLINE

ACCT_TYPE_LAST = _gnucash_core_c.ACCT_TYPE_LAST


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PLACEHOLDER_THIS = _gnucash_core_c.PLACEHOLDER_THIS

PLACEHOLDER_CHILD = _gnucash_core_c.PLACEHOLDER_CHILD


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

ACCOUNT_NAME_ = _gnucash_core_c.ACCOUNT_NAME_

ACCOUNT_CODE_ = _gnucash_core_c.ACCOUNT_CODE_

ACCOUNT_DESCRIPTION_ = _gnucash_core_c.ACCOUNT_DESCRIPTION_

ACCOUNT_COLOR_ = _gnucash_core_c.ACCOUNT_COLOR_

ACCOUNT_FILTER_ = _gnucash_core_c.ACCOUNT_FILTER_

ACCOUNT_SORT_ORDER_ = _gnucash_core_c.ACCOUNT_SORT_ORDER_

ACCOUNT_SORT_REVERSED_ = _gnucash_core_c.ACCOUNT_SORT_REVERSED_

ACCOUNT_NOTES_ = _gnucash_core_c.ACCOUNT_NOTES_

ACCOUNT_BALANCE_ = _gnucash_core_c.ACCOUNT_BALANCE_

ACCOUNT_NOCLOSING_ = _gnucash_core_c.ACCOUNT_NOCLOSING_

ACCOUNT_CLEARED_ = _gnucash_core_c.ACCOUNT_CLEARED_

ACCOUNT_RECONCILED_ = _gnucash_core_c.ACCOUNT_RECONCILED_

ACCOUNT_PRESENT_ = _gnucash_core_c.ACCOUNT_PRESENT_

ACCOUNT_FUTURE_MINIMUM_ = _gnucash_core_c.ACCOUNT_FUTURE_MINIMUM_

ACCOUNT_TAX_RELATED = _gnucash_core_c.ACCOUNT_TAX_RELATED

ACCOUNT_TYPE_ = _gnucash_core_c.ACCOUNT_TYPE_

ACCOUNT_SCU = _gnucash_core_c.ACCOUNT_SCU

ACCOUNT_NSCU = _gnucash_core_c.ACCOUNT_NSCU

ACCOUNT_PARENT = _gnucash_core_c.ACCOUNT_PARENT

ACCOUNT_MATCH_ALL_TYPE = _gnucash_core_c.ACCOUNT_MATCH_ALL_TYPE


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

TXN_TYPE_INVOICE = _gnucash_core_c.TXN_TYPE_INVOICE

TXN_TYPE_PAYMENT = _gnucash_core_c.TXN_TYPE_PAYMENT

TXN_TYPE_LINK = _gnucash_core_c.TXN_TYPE_LINK


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TRANS_NUM = _gnucash_core_c.TRANS_NUM

TRANS_DESCRIPTION = _gnucash_core_c.TRANS_DESCRIPTION

TRANS_DATE_ENTERED = _gnucash_core_c.TRANS_DATE_ENTERED

TRANS_DATE_POSTED = _gnucash_core_c.TRANS_DATE_POSTED

TRANS_DATE_DUE = _gnucash_core_c.TRANS_DATE_DUE

TRANS_IMBALANCE = _gnucash_core_c.TRANS_IMBALANCE

TRANS_IS_BALANCED = _gnucash_core_c.TRANS_IS_BALANCED

TRANS_IS_CLOSING = _gnucash_core_c.TRANS_IS_CLOSING

TRANS_NOTES = _gnucash_core_c.TRANS_NOTES

TRANS_ASSOCIATION = _gnucash_core_c.TRANS_ASSOCIATION

TRANS_TYPE = _gnucash_core_c.TRANS_TYPE

TRANS_VOID_STATUS = _gnucash_core_c.TRANS_VOID_STATUS

TRANS_VOID_REASON = _gnucash_core_c.TRANS_VOID_REASON

TRANS_VOID_TIME = _gnucash_core_c.TRANS_VOID_TIME

TRANS_SPLITLIST = _gnucash_core_c.TRANS_SPLITLIST

RECONCILED_MATCH_TYPE = _gnucash_core_c.RECONCILED_MATCH_TYPE

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

LOT_BALANCE = _gnucash_core_c.LOT_BALANCE

LOT_TITLE = _gnucash_core_c.LOT_TITLE

LOT_NOTES = _gnucash_core_c.LOT_NOTES

QOF_MOD_BACKEND = _gnucash_core_c.QOF_MOD_BACKEND

ERR_BACKEND_NO_ERR = _gnucash_core_c.ERR_BACKEND_NO_ERR

ERR_BACKEND_NO_HANDLER = _gnucash_core_c.ERR_BACKEND_NO_HANDLER

ERR_BACKEND_NO_BACKEND = _gnucash_core_c.ERR_BACKEND_NO_BACKEND

ERR_BACKEND_BAD_URL = _gnucash_core_c.ERR_BACKEND_BAD_URL

ERR_BACKEND_NO_SUCH_DB = _gnucash_core_c.ERR_BACKEND_NO_SUCH_DB

ERR_BACKEND_CANT_CONNECT = _gnucash_core_c.ERR_BACKEND_CANT_CONNECT

ERR_BACKEND_CONN_LOST = _gnucash_core_c.ERR_BACKEND_CONN_LOST

ERR_BACKEND_LOCKED = _gnucash_core_c.ERR_BACKEND_LOCKED

ERR_BACKEND_STORE_EXISTS = _gnucash_core_c.ERR_BACKEND_STORE_EXISTS

ERR_BACKEND_READONLY = _gnucash_core_c.ERR_BACKEND_READONLY

ERR_BACKEND_TOO_NEW = _gnucash_core_c.ERR_BACKEND_TOO_NEW

ERR_BACKEND_DATA_CORRUPT = _gnucash_core_c.ERR_BACKEND_DATA_CORRUPT

ERR_BACKEND_SERVER_ERR = _gnucash_core_c.ERR_BACKEND_SERVER_ERR

ERR_BACKEND_ALLOC = _gnucash_core_c.ERR_BACKEND_ALLOC

ERR_BACKEND_PERM = _gnucash_core_c.ERR_BACKEND_PERM

ERR_BACKEND_MODIFIED = _gnucash_core_c.ERR_BACKEND_MODIFIED

ERR_BACKEND_MOD_DESTROY = _gnucash_core_c.ERR_BACKEND_MOD_DESTROY

ERR_BACKEND_MISC = _gnucash_core_c.ERR_BACKEND_MISC

ERR_QOF_OVERFLOW = _gnucash_core_c.ERR_QOF_OVERFLOW

ERR_FILEIO_FILE_BAD_READ = _gnucash_core_c.ERR_FILEIO_FILE_BAD_READ

ERR_FILEIO_FILE_EMPTY = _gnucash_core_c.ERR_FILEIO_FILE_EMPTY

ERR_FILEIO_FILE_LOCKERR = _gnucash_core_c.ERR_FILEIO_FILE_LOCKERR

ERR_FILEIO_FILE_NOT_FOUND = _gnucash_core_c.ERR_FILEIO_FILE_NOT_FOUND

ERR_FILEIO_FILE_TOO_OLD = _gnucash_core_c.ERR_FILEIO_FILE_TOO_OLD

ERR_FILEIO_UNKNOWN_FILE_TYPE = _gnucash_core_c.ERR_FILEIO_UNKNOWN_FILE_TYPE

ERR_FILEIO_PARSE_ERROR = _gnucash_core_c.ERR_FILEIO_PARSE_ERROR

ERR_FILEIO_BACKUP_ERROR = _gnucash_core_c.ERR_FILEIO_BACKUP_ERROR

ERR_FILEIO_WRITE_ERROR = _gnucash_core_c.ERR_FILEIO_WRITE_ERROR

ERR_FILEIO_READ_ERROR = _gnucash_core_c.ERR_FILEIO_READ_ERROR

ERR_FILEIO_NO_ENCODING = _gnucash_core_c.ERR_FILEIO_NO_ENCODING

ERR_FILEIO_FILE_EACCES = _gnucash_core_c.ERR_FILEIO_FILE_EACCES

ERR_FILEIO_RESERVED_WRITE = _gnucash_core_c.ERR_FILEIO_RESERVED_WRITE

ERR_FILEIO_FILE_UPGRADE = _gnucash_core_c.ERR_FILEIO_FILE_UPGRADE

ERR_NETIO_SHORT_READ = _gnucash_core_c.ERR_NETIO_SHORT_READ

ERR_NETIO_WRONG_CONTENT_TYPE = _gnucash_core_c.ERR_NETIO_WRONG_CONTENT_TYPE

ERR_NETIO_NOT_GNCXML = _gnucash_core_c.ERR_NETIO_NOT_GNCXML

ERR_SQL_MISSING_DATA = _gnucash_core_c.ERR_SQL_MISSING_DATA

ERR_SQL_DB_TOO_OLD = _gnucash_core_c.ERR_SQL_DB_TOO_OLD

ERR_SQL_DB_TOO_NEW = _gnucash_core_c.ERR_SQL_DB_TOO_NEW

ERR_SQL_DB_BUSY = _gnucash_core_c.ERR_SQL_DB_BUSY

ERR_SQL_BAD_DBI = _gnucash_core_c.ERR_SQL_BAD_DBI

ERR_SQL_DBI_UNTESTABLE = _gnucash_core_c.ERR_SQL_DBI_UNTESTABLE

ERR_RPC_HOST_UNK = _gnucash_core_c.ERR_RPC_HOST_UNK

ERR_RPC_CANT_BIND = _gnucash_core_c.ERR_RPC_CANT_BIND

ERR_RPC_CANT_ACCEPT = _gnucash_core_c.ERR_RPC_CANT_ACCEPT

ERR_RPC_NO_CONNECTION = _gnucash_core_c.ERR_RPC_NO_CONNECTION

ERR_RPC_BAD_VERSION = _gnucash_core_c.ERR_RPC_BAD_VERSION

ERR_RPC_FAILED = _gnucash_core_c.ERR_RPC_FAILED

ERR_RPC_NOT_ADDED = _gnucash_core_c.ERR_RPC_NOT_ADDED


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

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

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

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

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

def qof_finalize_backend_libraries() -> "void":
    r"""qof_finalize_backend_libraries()"""
    return _gnucash_core_c.qof_finalize_backend_libraries()

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def qof_session_end(session: "QofSession *") -> "void":
    r"""qof_session_end(QofSession * session)"""
    return _gnucash_core_c.qof_session_end(session)
QOF_STDOUT = _gnucash_core_c.QOF_STDOUT


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QOF_ID_BOOK = _gnucash_core_c.QOF_ID_BOOK

QOF_ID_SESSION = _gnucash_core_c.QOF_ID_SESSION


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

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

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

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

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

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

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

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

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

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

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

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

def qof_collection_from_glist(type: "QofIdType", glist: "GList const *") -> "QofCollection *":
    r"""qof_collection_from_glist(QofIdType type, GList const * glist) -> QofCollection *"""
    return _gnucash_core_c.qof_collection_from_glist(type, glist)
QOF_MOD_QUERY = _gnucash_core_c.QOF_MOD_QUERY

QOF_QUERY_AND = _gnucash_core_c.QOF_QUERY_AND

QOF_QUERY_OR = _gnucash_core_c.QOF_QUERY_OR

QOF_QUERY_NAND = _gnucash_core_c.QOF_QUERY_NAND

QOF_QUERY_NOR = _gnucash_core_c.QOF_QUERY_NOR

QOF_QUERY_XOR = _gnucash_core_c.QOF_QUERY_XOR

QUERY_DEFAULT_SORT = _gnucash_core_c.QUERY_DEFAULT_SORT

QOF_PARAM_BOOK = _gnucash_core_c.QOF_PARAM_BOOK

QOF_PARAM_GUID = _gnucash_core_c.QOF_PARAM_GUID

QOF_PARAM_KVP = _gnucash_core_c.QOF_PARAM_KVP

QOF_PARAM_ACTIVE = _gnucash_core_c.QOF_PARAM_ACTIVE

QOF_PARAM_VERSION = _gnucash_core_c.QOF_PARAM_VERSION


def qof_query_init() -> "void":
    r"""qof_query_init()"""
    return _gnucash_core_c.qof_query_init()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QOF_COMPARE_LTE = _gnucash_core_c.QOF_COMPARE_LTE

QOF_COMPARE_EQUAL = _gnucash_core_c.QOF_COMPARE_EQUAL

QOF_COMPARE_GT = _gnucash_core_c.QOF_COMPARE_GT

QOF_COMPARE_GTE = _gnucash_core_c.QOF_COMPARE_GTE

QOF_COMPARE_NEQ = _gnucash_core_c.QOF_COMPARE_NEQ

QOF_COMPARE_CONTAINS = _gnucash_core_c.QOF_COMPARE_CONTAINS

QOF_COMPARE_NCONTAINS = _gnucash_core_c.QOF_COMPARE_NCONTAINS

QOF_STRING_MATCH_NORMAL = _gnucash_core_c.QOF_STRING_MATCH_NORMAL

QOF_STRING_MATCH_CASEINSENSITIVE = _gnucash_core_c.QOF_STRING_MATCH_CASEINSENSITIVE

QOF_DATE_MATCH_NORMAL = _gnucash_core_c.QOF_DATE_MATCH_NORMAL

QOF_DATE_MATCH_DAY = _gnucash_core_c.QOF_DATE_MATCH_DAY

QOF_NUMERIC_MATCH_DEBIT = _gnucash_core_c.QOF_NUMERIC_MATCH_DEBIT

QOF_NUMERIC_MATCH_CREDIT = _gnucash_core_c.QOF_NUMERIC_MATCH_CREDIT

QOF_NUMERIC_MATCH_ANY = _gnucash_core_c.QOF_NUMERIC_MATCH_ANY

QOF_GUID_MATCH_ANY = _gnucash_core_c.QOF_GUID_MATCH_ANY

QOF_GUID_MATCH_NONE = _gnucash_core_c.QOF_GUID_MATCH_NONE

QOF_GUID_MATCH_NULL = _gnucash_core_c.QOF_GUID_MATCH_NULL

QOF_GUID_MATCH_ALL = _gnucash_core_c.QOF_GUID_MATCH_ALL

QOF_GUID_MATCH_LIST_ANY = _gnucash_core_c.QOF_GUID_MATCH_LIST_ANY

QOF_CHAR_MATCH_ANY = _gnucash_core_c.QOF_CHAR_MATCH_ANY

QOF_CHAR_MATCH_NONE = _gnucash_core_c.QOF_CHAR_MATCH_NONE

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GNC_NUMERIC_RND_MASK = _gnucash_core_c.GNC_NUMERIC_RND_MASK

GNC_NUMERIC_DENOM_MASK = _gnucash_core_c.GNC_NUMERIC_DENOM_MASK

GNC_NUMERIC_SIGFIGS_MASK = _gnucash_core_c.GNC_NUMERIC_SIGFIGS_MASK

GNC_HOW_RND_FLOOR = _gnucash_core_c.GNC_HOW_RND_FLOOR

GNC_HOW_RND_CEIL = _gnucash_core_c.GNC_HOW_RND_CEIL

GNC_HOW_RND_TRUNC = _gnucash_core_c.GNC_HOW_RND_TRUNC

GNC_HOW_RND_PROMOTE = _gnucash_core_c.GNC_HOW_RND_PROMOTE

GNC_HOW_RND_ROUND_HALF_DOWN = _gnucash_core_c.GNC_HOW_RND_ROUND_HALF_DOWN

GNC_HOW_RND_ROUND_HALF_UP = _gnucash_core_c.GNC_HOW_RND_ROUND_HALF_UP

GNC_HOW_RND_ROUND = _gnucash_core_c.GNC_HOW_RND_ROUND

GNC_HOW_RND_NEVER = _gnucash_core_c.GNC_HOW_RND_NEVER

GNC_HOW_DENOM_EXACT = _gnucash_core_c.GNC_HOW_DENOM_EXACT

GNC_HOW_DENOM_REDUCE = _gnucash_core_c.GNC_HOW_DENOM_REDUCE

GNC_HOW_DENOM_LCD = _gnucash_core_c.GNC_HOW_DENOM_LCD

GNC_HOW_DENOM_FIXED = _gnucash_core_c.GNC_HOW_DENOM_FIXED

GNC_HOW_DENOM_SIGFIG = _gnucash_core_c.GNC_HOW_DENOM_SIGFIG

GNC_ERROR_OK = _gnucash_core_c.GNC_ERROR_OK

GNC_ERROR_ARG = _gnucash_core_c.GNC_ERROR_ARG

GNC_ERROR_OVERFLOW = _gnucash_core_c.GNC_ERROR_OVERFLOW

GNC_ERROR_DENOM_DIFF = _gnucash_core_c.GNC_ERROR_DENOM_DIFF

GNC_ERROR_REMAINDER = _gnucash_core_c.GNC_ERROR_REMAINDER

GNC_DENOM_AUTO = _gnucash_core_c.GNC_DENOM_AUTO


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GNC_COMMODITY_NS_LEGACY = _gnucash_core_c.GNC_COMMODITY_NS_LEGACY

GNC_COMMODITY_NS_TEMPLATE = _gnucash_core_c.GNC_COMMODITY_NS_TEMPLATE

GNC_COMMODITY_NS_ISO = _gnucash_core_c.GNC_COMMODITY_NS_ISO

GNC_COMMODITY_NS_CURRENCY = _gnucash_core_c.GNC_COMMODITY_NS_CURRENCY

GNC_COMMODITY_NS_NASDAQ = _gnucash_core_c.GNC_COMMODITY_NS_NASDAQ

GNC_COMMODITY_NS_NYSE = _gnucash_core_c.GNC_COMMODITY_NS_NYSE

GNC_COMMODITY_NS_EUREX = _gnucash_core_c.GNC_COMMODITY_NS_EUREX

GNC_COMMODITY_NS_MUTUAL = _gnucash_core_c.GNC_COMMODITY_NS_MUTUAL

GNC_COMMODITY_NS_AMEX = _gnucash_core_c.GNC_COMMODITY_NS_AMEX

GNC_COMMODITY_NS_ASX = _gnucash_core_c.GNC_COMMODITY_NS_ASX

GNC_COMMODITY_MAX_FRACTION = _gnucash_core_c.GNC_COMMODITY_MAX_FRACTION

SOURCE_SINGLE = _gnucash_core_c.SOURCE_SINGLE

SOURCE_MULTI = _gnucash_core_c.SOURCE_MULTI

SOURCE_UNKNOWN = _gnucash_core_c.SOURCE_UNKNOWN

SOURCE_MAX = _gnucash_core_c.SOURCE_MAX

SOURCE_CURRENCY = _gnucash_core_c.SOURCE_CURRENCY


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

GNC_OWNER_NONE = _gnucash_core_c.GNC_OWNER_NONE

GNC_OWNER_UNDEFINED = _gnucash_core_c.GNC_OWNER_UNDEFINED

GNC_OWNER_CUSTOMER = _gnucash_core_c.GNC_OWNER_CUSTOMER

GNC_OWNER_JOB = _gnucash_core_c.GNC_OWNER_JOB

GNC_OWNER_VENDOR = _gnucash_core_c.GNC_OWNER_VENDOR

GNC_OWNER_EMPLOYEE = _gnucash_core_c.GNC_OWNER_EMPLOYEE


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

OWNER_TYPE_STRING = _gnucash_core_c.OWNER_TYPE_STRING

OWNER_CUSTOMER = _gnucash_core_c.OWNER_CUSTOMER

OWNER_JOB = _gnucash_core_c.OWNER_JOB

OWNER_VENDOR = _gnucash_core_c.OWNER_VENDOR

OWNER_EMPLOYEE = _gnucash_core_c.OWNER_EMPLOYEE

OWNER_PARENT = _gnucash_core_c.OWNER_PARENT

OWNER_PARENTG = _gnucash_core_c.OWNER_PARENTG

OWNER_NAME = _gnucash_core_c.OWNER_NAME

OWNER_FROM_LOT = _gnucash_core_c.OWNER_FROM_LOT


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CUSTOMER_NAME = _gnucash_core_c.CUSTOMER_NAME

CUSTOMER_ADDR = _gnucash_core_c.CUSTOMER_ADDR

CUSTOMER_SHIPADDR = _gnucash_core_c.CUSTOMER_SHIPADDR

CUSTOMER_NOTES = _gnucash_core_c.CUSTOMER_NOTES

CUSTOMER_DISCOUNT = _gnucash_core_c.CUSTOMER_DISCOUNT

CUSTOMER_CREDIT = _gnucash_core_c.CUSTOMER_CREDIT

CUSTOMER_TT_OVER = _gnucash_core_c.CUSTOMER_TT_OVER

CUSTOMER_TAX_INC = _gnucash_core_c.CUSTOMER_TAX_INC

CUSTOMER_TERMS = _gnucash_core_c.CUSTOMER_TERMS

CUSTOMER_ACTIVE = _gnucash_core_c.CUSTOMER_ACTIVE

CUSTOMER_SLOTS = _gnucash_core_c.CUSTOMER_SLOTS


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

EMPLOYEE_USERNAME = _gnucash_core_c.EMPLOYEE_USERNAME

EMPLOYEE_NAME = _gnucash_core_c.EMPLOYEE_NAME

EMPLOYEE_ADDR = _gnucash_core_c.EMPLOYEE_ADDR

EMPLOYEE_LANGUAGE = _gnucash_core_c.EMPLOYEE_LANGUAGE

EMPLOYEE_ACL = _gnucash_core_c.EMPLOYEE_ACL

EMPLOYEE_WORKDAY = _gnucash_core_c.EMPLOYEE_WORKDAY

EMPLOYEE_RATE = _gnucash_core_c.EMPLOYEE_RATE

EMPLOYEE_CC = _gnucash_core_c.EMPLOYEE_CC


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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

VENDOR_NAME = _gnucash_core_c.VENDOR_NAME

VENDOR_ADDR = _gnucash_core_c.VENDOR_ADDR

VENDOR_NOTES = _gnucash_core_c.VENDOR_NOTES

VENDOR_TERMS = _gnucash_core_c.VENDOR_TERMS

VENDOR_TAX_INC = _gnucash_core_c.VENDOR_TAX_INC

VENDOR_ACTIVE = _gnucash_core_c.VENDOR_ACTIVE

VENDOR_TAX_OVERRIDE = _gnucash_core_c.VENDOR_TAX_OVERRIDE

VENDOR_TAX_TABLE = _gnucash_core_c.VENDOR_TAX_TABLE


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

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

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

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

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

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

GNC_ID_ADDRESS = _gnucash_core_c.GNC_ID_ADDRESS


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncAddressEqual(a: "GncAddress const *", b: "GncAddress const *") -> "gboolean":
    r"""gncAddressEqual(GncAddress const * a, GncAddress const * b) -> gboolean"""
    return _gnucash_core_c.gncAddressEqual(a, b)
ADDRESS_NAME = _gnucash_core_c.ADDRESS_NAME

ADDRESS_ONE = _gnucash_core_c.ADDRESS_ONE

ADDRESS_TWO = _gnucash_core_c.ADDRESS_TWO

ADDRESS_THREE = _gnucash_core_c.ADDRESS_THREE

ADDRESS_FOUR = _gnucash_core_c.ADDRESS_FOUR

ADDRESS_PHONE = _gnucash_core_c.ADDRESS_PHONE

ADDRESS_FAX = _gnucash_core_c.ADDRESS_FAX

ADDRESS_EMAIL = _gnucash_core_c.ADDRESS_EMAIL

ADDRESS_OWNER = _gnucash_core_c.ADDRESS_OWNER

GNC_ID_BILLTERM = _gnucash_core_c.GNC_ID_BILLTERM


def gnc_billterm_get_type() -> "GType":
    r"""gnc_billterm_get_type() -> GType"""
    return _gnucash_core_c.gnc_billterm_get_type()
GNC_BILLTERM_NAME = _gnucash_core_c.GNC_BILLTERM_NAME

GNC_BILLTERM_DESC = _gnucash_core_c.GNC_BILLTERM_DESC

GNC_BILLTERM_DUEDAYS = _gnucash_core_c.GNC_BILLTERM_DUEDAYS

GNC_BILLTERM_DISCDAYS = _gnucash_core_c.GNC_BILLTERM_DISCDAYS

GNC_BILLTERM_CUTOFF = _gnucash_core_c.GNC_BILLTERM_CUTOFF

GNC_BILLTERM_TYPE = _gnucash_core_c.GNC_BILLTERM_TYPE

GNC_BILLTERM_DISCOUNT = _gnucash_core_c.GNC_BILLTERM_DISCOUNT

GNC_BILLTERM_REFCOUNT = _gnucash_core_c.GNC_BILLTERM_REFCOUNT

GNC_TERM_TYPE_DAYS = _gnucash_core_c.GNC_TERM_TYPE_DAYS

GNC_TERM_TYPE_PROXIMO = _gnucash_core_c.GNC_TERM_TYPE_PROXIMO


def gncBillTermCreate(book: "QofBook *") -> "GncBillTerm *":
    r"""gncBillTermCreate(QofBook * book) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermCreate(book)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def gncBillTermGetTerms(book: "QofBook *") -> "GList *":
    r"""gncBillTermGetTerms(QofBook * book) -> GList *"""
    return _gnucash_core_c.gncBillTermGetTerms(book)

def gncBillTermGetName(term: "GncBillTerm const *") -> "char const *":
    r"""gncBillTermGetName(GncBillTerm const * term) -> char const *"""
    return _gnucash_core_c.gncBillTermGetName(term)

def gncBillTermGetDescription(term: "GncBillTerm const *") -> "char const *":
    r"""gncBillTermGetDescription(GncBillTerm const * term) -> char const *"""
    return _gnucash_core_c.gncBillTermGetDescription(term)

def gncBillTermGetType(term: "GncBillTerm const *") -> "GncBillTermType":
    r"""gncBillTermGetType(GncBillTerm const * term) -> GncBillTermType"""
    return _gnucash_core_c.gncBillTermGetType(term)

def gncBillTermGetDueDays(term: "GncBillTerm const *") -> "gint":
    r"""gncBillTermGetDueDays(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetDueDays(term)

def gncBillTermGetDiscountDays(term: "GncBillTerm const *") -> "gint":
    r"""gncBillTermGetDiscountDays(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetDiscountDays(term)

def gncBillTermGetDiscount(term: "GncBillTerm const *") -> "gnc_numeric":
    r"""gncBillTermGetDiscount(GncBillTerm const * term) -> _gnc_numeric"""
    return _gnucash_core_c.gncBillTermGetDiscount(term)

def gncBillTermGetCutoff(term: "GncBillTerm const *") -> "gint":
    r"""gncBillTermGetCutoff(GncBillTerm const * term) -> gint"""
    return _gnucash_core_c.gncBillTermGetCutoff(term)

def gncBillTermIsDirty(term: "GncBillTerm const *") -> "gboolean":
    r"""gncBillTermIsDirty(GncBillTerm const * term) -> gboolean"""
    return _gnucash_core_c.gncBillTermIsDirty(term)

def gncBillTermGetParent(term: "GncBillTerm const *") -> "GncBillTerm *":
    r"""gncBillTermGetParent(GncBillTerm const * term) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermGetParent(term)

def gncBillTermReturnChild(term: "GncBillTerm *", make_new: "gboolean") -> "GncBillTerm *":
    r"""gncBillTermReturnChild(GncBillTerm * term, gboolean make_new) -> GncBillTerm *"""
    return _gnucash_core_c.gncBillTermReturnChild(term, make_new)

def gncBillTermGetRefcount(term: "GncBillTerm const *") -> "gint64":
    r"""gncBillTermGetRefcount(GncBillTerm const * term) -> gint64"""
    return _gnucash_core_c.gncBillTermGetRefcount(term)

def gncBillTermCompare(a: "GncBillTerm const *", b: "GncBillTerm const *") -> "int":
    r"""gncBillTermCompare(GncBillTerm const * a, GncBillTerm const * b) -> int"""
    return _gnucash_core_c.gncBillTermCompare(a, b)

def gncBillTermEqual(a: "GncBillTerm const *", b: "GncBillTerm const *") -> "gboolean":
    r"""gncBillTermEqual(GncBillTerm const * a, GncBillTerm const * b) -> gboolean"""
    return _gnucash_core_c.gncBillTermEqual(a, b)

def gncBillTermIsFamily(a: "GncBillTerm const *", b: "GncBillTerm const *") -> "gboolean":
    r"""gncBillTermIsFamily(GncBillTerm const * a, GncBillTerm const * b) -> gboolean"""
    return _gnucash_core_c.gncBillTermIsFamily(a, b)

def gncBillTermComputeDueDate(term: "GncBillTerm const *", post_date: "time64") -> "time64":
    r"""gncBillTermComputeDueDate(GncBillTerm const * term, time64 post_date) -> time64"""
    return _gnucash_core_c.gncBillTermComputeDueDate(term, post_date)
GNC_ID_INVOICE = _gnucash_core_c.GNC_ID_INVOICE

GNC_INVOICE_UNDEFINED = _gnucash_core_c.GNC_INVOICE_UNDEFINED

GNC_INVOICE_CUST_INVOICE = _gnucash_core_c.GNC_INVOICE_CUST_INVOICE

GNC_INVOICE_VEND_INVOICE = _gnucash_core_c.GNC_INVOICE_VEND_INVOICE

GNC_INVOICE_EMPL_INVOICE = _gnucash_core_c.GNC_INVOICE_EMPL_INVOICE

GNC_INVOICE_CUST_CREDIT_NOTE = _gnucash_core_c.GNC_INVOICE_CUST_CREDIT_NOTE

GNC_INVOICE_VEND_CREDIT_NOTE = _gnucash_core_c.GNC_INVOICE_VEND_CREDIT_NOTE

GNC_INVOICE_EMPL_CREDIT_NOTE = _gnucash_core_c.GNC_INVOICE_EMPL_CREDIT_NOTE

GNC_INVOICE_NUM_TYPES = _gnucash_core_c.GNC_INVOICE_NUM_TYPES


def gnc_invoice_get_type() -> "GType":
    r"""gnc_invoice_get_type() -> GType"""
    return _gnucash_core_c.gnc_invoice_get_type()

def gncInvoiceCreate(book: "QofBook *") -> "GncInvoice *":
    r"""gncInvoiceCreate(QofBook * book) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceCreate(book)

def gncInvoiceDestroy(invoice: "GncInvoice *") -> "void":
    r"""gncInvoiceDestroy(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceDestroy(invoice)

def gncInvoiceCopy(other_invoice: "GncInvoice const *") -> "GncInvoice *":
    r"""gncInvoiceCopy(GncInvoice const * other_invoice) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceCopy(other_invoice)

def gncInvoiceSetID(invoice: "GncInvoice *", id: "char const *") -> "void":
    r"""gncInvoiceSetID(GncInvoice * invoice, char const * id)"""
    return _gnucash_core_c.gncInvoiceSetID(invoice, id)

def gncInvoiceSetOwner(invoice: "GncInvoice *", owner: "GncOwner *") -> "void":
    r"""gncInvoiceSetOwner(GncInvoice * invoice, GncOwner * owner)"""
    return _gnucash_core_c.gncInvoiceSetOwner(invoice, owner)

def gncInvoiceSetDateOpenedGDate(invoice: "GncInvoice *", date: "GDate const *") -> "void":
    r"""gncInvoiceSetDateOpenedGDate(GncInvoice * invoice, GDate const * date)"""
    return _gnucash_core_c.gncInvoiceSetDateOpenedGDate(invoice, date)

def gncInvoiceSetDateOpened(invoice: "GncInvoice *", date: "time64") -> "void":
    r"""gncInvoiceSetDateOpened(GncInvoice * invoice, time64 date)"""
    return _gnucash_core_c.gncInvoiceSetDateOpened(invoice, date)

def gncInvoiceSetDatePosted(invoice: "GncInvoice *", date: "time64") -> "void":
    r"""gncInvoiceSetDatePosted(GncInvoice * invoice, time64 date)"""
    return _gnucash_core_c.gncInvoiceSetDatePosted(invoice, date)

def gncInvoiceSetTerms(invoice: "GncInvoice *", terms: "GncBillTerm *") -> "void":
    r"""gncInvoiceSetTerms(GncInvoice * invoice, GncBillTerm * terms)"""
    return _gnucash_core_c.gncInvoiceSetTerms(invoice, terms)

def gncInvoiceSetBillingID(invoice: "GncInvoice *", billing_id: "char const *") -> "void":
    r"""gncInvoiceSetBillingID(GncInvoice * invoice, char const * billing_id)"""
    return _gnucash_core_c.gncInvoiceSetBillingID(invoice, billing_id)

def gncInvoiceSetNotes(invoice: "GncInvoice *", notes: "char const *") -> "void":
    r"""gncInvoiceSetNotes(GncInvoice * invoice, char const * notes)"""
    return _gnucash_core_c.gncInvoiceSetNotes(invoice, notes)

def gncInvoiceSetCurrency(invoice: "GncInvoice *", currency: "gnc_commodity *") -> "void":
    r"""gncInvoiceSetCurrency(GncInvoice * invoice, gnc_commodity * currency)"""
    return _gnucash_core_c.gncInvoiceSetCurrency(invoice, currency)

def gncInvoiceSetActive(invoice: "GncInvoice *", active: "gboolean") -> "void":
    r"""gncInvoiceSetActive(GncInvoice * invoice, gboolean active)"""
    return _gnucash_core_c.gncInvoiceSetActive(invoice, active)

def gncInvoiceSetIsCreditNote(invoice: "GncInvoice *", credit_note: "gboolean") -> "void":
    r"""gncInvoiceSetIsCreditNote(GncInvoice * invoice, gboolean credit_note)"""
    return _gnucash_core_c.gncInvoiceSetIsCreditNote(invoice, credit_note)

def gncInvoiceSetBillTo(invoice: "GncInvoice *", billto: "GncOwner *") -> "void":
    r"""gncInvoiceSetBillTo(GncInvoice * invoice, GncOwner * billto)"""
    return _gnucash_core_c.gncInvoiceSetBillTo(invoice, billto)

def gncInvoiceSetToChargeAmount(invoice: "GncInvoice *", amount: "_gnc_numeric") -> "void":
    r"""gncInvoiceSetToChargeAmount(GncInvoice * invoice, _gnc_numeric amount)"""
    return _gnucash_core_c.gncInvoiceSetToChargeAmount(invoice, amount)

def gncInvoiceAddEntry(invoice: "GncInvoice *", entry: "GncEntry *") -> "void":
    r"""gncInvoiceAddEntry(GncInvoice * invoice, GncEntry * entry)"""
    return _gnucash_core_c.gncInvoiceAddEntry(invoice, entry)

def gncInvoiceRemoveEntry(invoice: "GncInvoice *", entry: "GncEntry *") -> "void":
    r"""gncInvoiceRemoveEntry(GncInvoice * invoice, GncEntry * entry)"""
    return _gnucash_core_c.gncInvoiceRemoveEntry(invoice, entry)

def gncInvoiceAddPrice(invoice: "GncInvoice *", price: "GNCPrice *") -> "void":
    r"""gncInvoiceAddPrice(GncInvoice * invoice, GNCPrice * price)"""
    return _gnucash_core_c.gncInvoiceAddPrice(invoice, price)

def gncBillAddEntry(bill: "GncInvoice *", entry: "GncEntry *") -> "void":
    r"""gncBillAddEntry(GncInvoice * bill, GncEntry * entry)"""
    return _gnucash_core_c.gncBillAddEntry(bill, entry)

def gncBillRemoveEntry(bill: "GncInvoice *", entry: "GncEntry *") -> "void":
    r"""gncBillRemoveEntry(GncInvoice * bill, GncEntry * entry)"""
    return _gnucash_core_c.gncBillRemoveEntry(bill, entry)

def gncInvoiceSortEntries(invoice: "GncInvoice *") -> "void":
    r"""gncInvoiceSortEntries(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceSortEntries(invoice)

def gncInvoiceRemoveEntries(invoice: "GncInvoice *") -> "void":
    r"""gncInvoiceRemoveEntries(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceRemoveEntries(invoice)

def gncInvoiceGetID(invoice: "GncInvoice const *") -> "char const *":
    r"""gncInvoiceGetID(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetID(invoice)

def gncInvoiceGetOwner(invoice: "GncInvoice const *") -> "GncOwner const *":
    r"""gncInvoiceGetOwner(GncInvoice const * invoice) -> GncOwner const *"""
    return _gnucash_core_c.gncInvoiceGetOwner(invoice)

def gncInvoiceGetDateOpened(invoice: "GncInvoice const *") -> "time64":
    r"""gncInvoiceGetDateOpened(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDateOpened(invoice)

def gncInvoiceGetDatePosted(invoice: "GncInvoice const *") -> "time64":
    r"""gncInvoiceGetDatePosted(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDatePosted(invoice)

def gncInvoiceGetDateDue(invoice: "GncInvoice const *") -> "time64":
    r"""gncInvoiceGetDateDue(GncInvoice const * invoice) -> time64"""
    return _gnucash_core_c.gncInvoiceGetDateDue(invoice)

def gncInvoiceGetTerms(invoice: "GncInvoice const *") -> "GncBillTerm *":
    r"""gncInvoiceGetTerms(GncInvoice const * invoice) -> GncBillTerm *"""
    return _gnucash_core_c.gncInvoiceGetTerms(invoice)

def gncInvoiceGetBillingID(invoice: "GncInvoice const *") -> "char const *":
    r"""gncInvoiceGetBillingID(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetBillingID(invoice)

def gncInvoiceGetNotes(invoice: "GncInvoice const *") -> "char const *":
    r"""gncInvoiceGetNotes(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetNotes(invoice)

def gncInvoiceGetOwnerType(invoice: "GncInvoice const *") -> "GncOwnerType":
    r"""gncInvoiceGetOwnerType(GncInvoice const * invoice) -> GncOwnerType"""
    return _gnucash_core_c.gncInvoiceGetOwnerType(invoice)

def gncInvoiceGetTypeListForOwnerType(type: "GncOwnerType const") -> "GList *":
    r"""gncInvoiceGetTypeListForOwnerType(GncOwnerType const type) -> GList *"""
    return _gnucash_core_c.gncInvoiceGetTypeListForOwnerType(type)

def gncInvoiceGetType(invoice: "GncInvoice const *") -> "GncInvoiceType":
    r"""gncInvoiceGetType(GncInvoice const * invoice) -> GncInvoiceType"""
    return _gnucash_core_c.gncInvoiceGetType(invoice)

def gncInvoiceGetTypeString(invoice: "GncInvoice const *") -> "char const *":
    r"""gncInvoiceGetTypeString(GncInvoice const * invoice) -> char const *"""
    return _gnucash_core_c.gncInvoiceGetTypeString(invoice)

def gncInvoiceGetCurrency(invoice: "GncInvoice const *") -> "gnc_commodity *":
    r"""gncInvoiceGetCurrency(GncInvoice const * invoice) -> gnc_commodity *"""
    return _gnucash_core_c.gncInvoiceGetCurrency(invoice)

def gncInvoiceGetBillTo(invoice: "GncInvoice *") -> "GncOwner *":
    r"""gncInvoiceGetBillTo(GncInvoice * invoice) -> GncOwner *"""
    return _gnucash_core_c.gncInvoiceGetBillTo(invoice)

def gncInvoiceGetToChargeAmount(invoice: "GncInvoice const *") -> "gnc_numeric":
    r"""gncInvoiceGetToChargeAmount(GncInvoice const * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetToChargeAmount(invoice)

def gncInvoiceGetActive(invoice: "GncInvoice const *") -> "gboolean":
    r"""gncInvoiceGetActive(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceGetActive(invoice)

def gncInvoiceGetIsCreditNote(invoice: "GncInvoice const *") -> "gboolean":
    r"""gncInvoiceGetIsCreditNote(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceGetIsCreditNote(invoice)

def gncInvoiceGetPostedLot(invoice: "GncInvoice const *") -> "GNCLot *":
    r"""gncInvoiceGetPostedLot(GncInvoice const * invoice) -> GNCLot *"""
    return _gnucash_core_c.gncInvoiceGetPostedLot(invoice)

def gncInvoiceGetPostedTxn(invoice: "GncInvoice const *") -> "Transaction *":
    r"""gncInvoiceGetPostedTxn(GncInvoice const * invoice) -> Transaction *"""
    return _gnucash_core_c.gncInvoiceGetPostedTxn(invoice)

def gncInvoiceGetPostedAcc(invoice: "GncInvoice const *") -> "Account *":
    r"""gncInvoiceGetPostedAcc(GncInvoice const * invoice) -> Account *"""
    return _gnucash_core_c.gncInvoiceGetPostedAcc(invoice)

def gncInvoiceGetTotal(invoice: "GncInvoice *") -> "gnc_numeric":
    r"""gncInvoiceGetTotal(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotal(invoice)

def gncInvoiceGetTotalOf(invoice: "GncInvoice *", type: "GncEntryPaymentType") -> "gnc_numeric":
    r"""gncInvoiceGetTotalOf(GncInvoice * invoice, GncEntryPaymentType type) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalOf(invoice, type)

def gncInvoiceGetTotalSubtotal(invoice: "GncInvoice *") -> "gnc_numeric":
    r"""gncInvoiceGetTotalSubtotal(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalSubtotal(invoice)

def gncInvoiceGetTotalTax(invoice: "GncInvoice *") -> "gnc_numeric":
    r"""gncInvoiceGetTotalTax(GncInvoice * invoice) -> _gnc_numeric"""
    return _gnucash_core_c.gncInvoiceGetTotalTax(invoice)

def gncInvoiceGetTotalTaxList(invoice: "GncInvoice *") -> "AccountValueList *":
    r"""gncInvoiceGetTotalTaxList(GncInvoice * invoice) -> AccountValueList *"""
    return _gnucash_core_c.gncInvoiceGetTotalTaxList(invoice)

def gncInvoiceGetEntries(invoice: "GncInvoice *") -> "EntryList *":
    r"""gncInvoiceGetEntries(GncInvoice * invoice) -> EntryList *"""
    return _gnucash_core_c.gncInvoiceGetEntries(invoice)

def gncInvoiceGetPrice(invoice: "GncInvoice *", commodity: "gnc_commodity *") -> "GNCPrice *":
    r"""gncInvoiceGetPrice(GncInvoice * invoice, gnc_commodity * commodity) -> GNCPrice *"""
    return _gnucash_core_c.gncInvoiceGetPrice(invoice, commodity)

def gncInvoiceAmountPositive(invoice: "GncInvoice const *") -> "gboolean":
    r"""gncInvoiceAmountPositive(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceAmountPositive(invoice)

def gncInvoiceGetForeignCurrencies(invoice: "GncInvoice const *") -> "GHashTable *":
    r"""gncInvoiceGetForeignCurrencies(GncInvoice const * invoice) -> GHashTable *"""
    return _gnucash_core_c.gncInvoiceGetForeignCurrencies(invoice)

def gncInvoicePostToAccount(invoice: "GncInvoice *", acc: "Account *", posted_date: "time64", due_date: "time64", memo: "char const *", accumulatesplits: "gboolean", autopay: "gboolean") -> "Transaction *":
    r"""gncInvoicePostToAccount(GncInvoice * invoice, Account * acc, time64 posted_date, time64 due_date, char const * memo, gboolean accumulatesplits, gboolean autopay) -> Transaction *"""
    return _gnucash_core_c.gncInvoicePostToAccount(invoice, acc, posted_date, due_date, memo, accumulatesplits, autopay)

def gncInvoiceUnpost(invoice: "GncInvoice *", reset_tax_tables: "gboolean") -> "gboolean":
    r"""gncInvoiceUnpost(GncInvoice * invoice, gboolean reset_tax_tables) -> gboolean"""
    return _gnucash_core_c.gncInvoiceUnpost(invoice, reset_tax_tables)

def gncInvoiceAutoApplyPayments(invoice: "GncInvoice *") -> "void":
    r"""gncInvoiceAutoApplyPayments(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceAutoApplyPayments(invoice)

def gncInvoiceApplyPayment(invoice: "GncInvoice const *", txn: "Transaction *", xfer_acc: "Account *", amount: "_gnc_numeric", exch: "_gnc_numeric", date: "time64", memo: "char const *", num: "char const *") -> "void":
    r"""gncInvoiceApplyPayment(GncInvoice const * invoice, Transaction * txn, Account * xfer_acc, _gnc_numeric amount, _gnc_numeric exch, time64 date, char const * memo, char const * num)"""
    return _gnucash_core_c.gncInvoiceApplyPayment(invoice, txn, xfer_acc, amount, exch, date, memo, num)

def gncInvoiceGetInvoiceFromTxn(txn: "Transaction const *") -> "GncInvoice *":
    r"""gncInvoiceGetInvoiceFromTxn(Transaction const * txn) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceGetInvoiceFromTxn(txn)

def gncInvoiceGetInvoiceFromLot(lot: "GNCLot *") -> "GncInvoice *":
    r"""gncInvoiceGetInvoiceFromLot(GNCLot * lot) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceGetInvoiceFromLot(lot)

def gncInvoiceLookup(book: "QofBook const *", guid: "GncGUID") -> "GncInvoice *":
    r"""gncInvoiceLookup(QofBook const * book, GncGUID guid) -> GncInvoice *"""
    return _gnucash_core_c.gncInvoiceLookup(book, guid)

def gncInvoiceBeginEdit(invoice: "GncInvoice *") -> "void":
    r"""gncInvoiceBeginEdit(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceBeginEdit(invoice)

def gncInvoiceCommitEdit(invoice: "GncInvoice *") -> "void":
    r"""gncInvoiceCommitEdit(GncInvoice * invoice)"""
    return _gnucash_core_c.gncInvoiceCommitEdit(invoice)

def gncInvoiceCompare(a: "GncInvoice const *", b: "GncInvoice const *") -> "int":
    r"""gncInvoiceCompare(GncInvoice const * a, GncInvoice const * b) -> int"""
    return _gnucash_core_c.gncInvoiceCompare(a, b)

def gncInvoiceIsPosted(invoice: "GncInvoice const *") -> "gboolean":
    r"""gncInvoiceIsPosted(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceIsPosted(invoice)

def gncInvoiceIsPaid(invoice: "GncInvoice const *") -> "gboolean":
    r"""gncInvoiceIsPaid(GncInvoice const * invoice) -> gboolean"""
    return _gnucash_core_c.gncInvoiceIsPaid(invoice)
INVOICE_ID = _gnucash_core_c.INVOICE_ID

INVOICE_OWNER = _gnucash_core_c.INVOICE_OWNER

INVOICE_OPENED = _gnucash_core_c.INVOICE_OPENED

INVOICE_POSTED = _gnucash_core_c.INVOICE_POSTED

INVOICE_DUE = _gnucash_core_c.INVOICE_DUE

INVOICE_IS_POSTED = _gnucash_core_c.INVOICE_IS_POSTED

INVOICE_IS_PAID = _gnucash_core_c.INVOICE_IS_PAID

INVOICE_TERMS = _gnucash_core_c.INVOICE_TERMS

INVOICE_BILLINGID = _gnucash_core_c.INVOICE_BILLINGID

INVOICE_NOTES = _gnucash_core_c.INVOICE_NOTES

INVOICE_ACC = _gnucash_core_c.INVOICE_ACC

INVOICE_POST_TXN = _gnucash_core_c.INVOICE_POST_TXN

INVOICE_POST_LOT = _gnucash_core_c.INVOICE_POST_LOT

INVOICE_IS_CN = _gnucash_core_c.INVOICE_IS_CN

INVOICE_TYPE = _gnucash_core_c.INVOICE_TYPE

INVOICE_TYPE_STRING = _gnucash_core_c.INVOICE_TYPE_STRING

INVOICE_BILLTO = _gnucash_core_c.INVOICE_BILLTO

INVOICE_ENTRIES = _gnucash_core_c.INVOICE_ENTRIES

INVOICE_JOB = _gnucash_core_c.INVOICE_JOB

INVOICE_FROM_LOT = _gnucash_core_c.INVOICE_FROM_LOT

INVOICE_FROM_TXN = _gnucash_core_c.INVOICE_FROM_TXN


def gncInvoiceGetBook(x: "GncInvoice *") -> "QofBook *":
    r"""gncInvoiceGetBook(GncInvoice * x) -> QofBook *"""
    return _gnucash_core_c.gncInvoiceGetBook(x)

def gncInvoiceEqual(a: "GncInvoice const *", b: "GncInvoice const *") -> "gboolean":
    r"""gncInvoiceEqual(GncInvoice const * a, GncInvoice const * b) -> gboolean"""
    return _gnucash_core_c.gncInvoiceEqual(a, b)

def gncInvoiceRegister() -> "gboolean":
    r"""gncInvoiceRegister() -> gboolean"""
    return _gnucash_core_c.gncInvoiceRegister()

def gncInvoiceNextID(book: "QofBook *", owner: "GncOwner const *") -> "gchar *":
    r"""gncInvoiceNextID(QofBook * book, GncOwner const * owner) -> gchar *"""
    return _gnucash_core_c.gncInvoiceNextID(book, owner)

def gncInvoiceSetPostedAcc(invoice: "GncInvoice *", acc: "Account *") -> "void":
    r"""gncInvoiceSetPostedAcc(GncInvoice * invoice, Account * acc)"""
    return _gnucash_core_c.gncInvoiceSetPostedAcc(invoice, acc)

def gncInvoiceSetPostedTxn(invoice: "GncInvoice *", txn: "Transaction *") -> "void":
    r"""gncInvoiceSetPostedTxn(GncInvoice * invoice, Transaction * txn)"""
    return _gnucash_core_c.gncInvoiceSetPostedTxn(invoice, txn)

def gncInvoiceSetPostedLot(invoice: "GncInvoice *", lot: "GNCLot *") -> "void":
    r"""gncInvoiceSetPostedLot(GncInvoice * invoice, GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceSetPostedLot(invoice, lot)

def gncInvoiceAttachToLot(invoice: "GncInvoice *", lot: "GNCLot *") -> "void":
    r"""gncInvoiceAttachToLot(GncInvoice * invoice, GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceAttachToLot(invoice, lot)

def gncInvoiceDetachFromLot(lot: "GNCLot *") -> "void":
    r"""gncInvoiceDetachFromLot(GNCLot * lot)"""
    return _gnucash_core_c.gncInvoiceDetachFromLot(lot)

def gncInvoiceAttachToTxn(invoice: "GncInvoice *", txn: "Transaction *") -> "void":
    r"""gncInvoiceAttachToTxn(GncInvoice * invoice, Transaction * txn)"""
    return _gnucash_core_c.gncInvoiceAttachToTxn(invoice, txn)
GNC_ID_JOB = _gnucash_core_c.GNC_ID_JOB


def gnc_job_get_type() -> "GType":
    r"""gnc_job_get_type() -> GType"""
    return _gnucash_core_c.gnc_job_get_type()

def gncJobCreate(book: "QofBook *") -> "GncJob *":
    r"""gncJobCreate(QofBook * book) -> GncJob *"""
    return _gnucash_core_c.gncJobCreate(book)

def gncJobDestroy(job: "GncJob *") -> "void":
    r"""gncJobDestroy(GncJob * job)"""
    return _gnucash_core_c.gncJobDestroy(job)

def gncJobSetID(job: "GncJob *", id: "char const *") -> "void":
    r"""gncJobSetID(GncJob * job, char const * id)"""
    return _gnucash_core_c.gncJobSetID(job, id)

def gncJobSetName(job: "GncJob *", jobname: "char const *") -> "void":
    r"""gncJobSetName(GncJob * job, char const * jobname)"""
    return _gnucash_core_c.gncJobSetName(job, jobname)

def gncJobSetReference(job: "GncJob *", owner_reference: "char const *") -> "void":
    r"""gncJobSetReference(GncJob * job, char const * owner_reference)"""
    return _gnucash_core_c.gncJobSetReference(job, owner_reference)

def gncJobSetRate(job: "GncJob *", rate: "_gnc_numeric") -> "void":
    r"""gncJobSetRate(GncJob * job, _gnc_numeric rate)"""
    return _gnucash_core_c.gncJobSetRate(job, rate)

def gncJobSetOwner(job: "GncJob *", owner: "GncOwner *") -> "void":
    r"""gncJobSetOwner(GncJob * job, GncOwner * owner)"""
    return _gnucash_core_c.gncJobSetOwner(job, owner)

def gncJobSetActive(job: "GncJob *", active: "gboolean") -> "void":
    r"""gncJobSetActive(GncJob * job, gboolean active)"""
    return _gnucash_core_c.gncJobSetActive(job, active)

def gncJobBeginEdit(job: "GncJob *") -> "void":
    r"""gncJobBeginEdit(GncJob * job)"""
    return _gnucash_core_c.gncJobBeginEdit(job)

def gncJobCommitEdit(job: "GncJob *") -> "void":
    r"""gncJobCommitEdit(GncJob * job)"""
    return _gnucash_core_c.gncJobCommitEdit(job)

def gncJobGetID(job: "GncJob const *") -> "char const *":
    r"""gncJobGetID(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetID(job)

def gncJobGetName(job: "GncJob const *") -> "char const *":
    r"""gncJobGetName(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetName(job)

def gncJobGetReference(job: "GncJob const *") -> "char const *":
    r"""gncJobGetReference(GncJob const * job) -> char const *"""
    return _gnucash_core_c.gncJobGetReference(job)

def gncJobGetRate(job: "GncJob const *") -> "gnc_numeric":
    r"""gncJobGetRate(GncJob const * job) -> _gnc_numeric"""
    return _gnucash_core_c.gncJobGetRate(job)

def gncJobGetOwner(job: "GncJob *") -> "GncOwner *":
    r"""gncJobGetOwner(GncJob * job) -> GncOwner *"""
    return _gnucash_core_c.gncJobGetOwner(job)

def gncJobGetActive(job: "GncJob const *") -> "gboolean":
    r"""gncJobGetActive(GncJob const * job) -> gboolean"""
    return _gnucash_core_c.gncJobGetActive(job)

def gncJobLookup(book: "QofBook const *", guid: "GncGUID") -> "GncJob *":
    r"""gncJobLookup(QofBook const * book, GncGUID guid) -> GncJob *"""
    return _gnucash_core_c.gncJobLookup(book, guid)

def gncJobCompare(a: "GncJob const *", b: "GncJob const *") -> "int":
    r"""gncJobCompare(GncJob const * a, GncJob const * b) -> int"""
    return _gnucash_core_c.gncJobCompare(a, b)

def gncJobEqual(a: "GncJob const *", b: "GncJob const *") -> "gboolean":
    r"""gncJobEqual(GncJob const * a, GncJob const * b) -> gboolean"""
    return _gnucash_core_c.gncJobEqual(a, b)
JOB_ID = _gnucash_core_c.JOB_ID

JOB_NAME = _gnucash_core_c.JOB_NAME

JOB_REFERENCE = _gnucash_core_c.JOB_REFERENCE

JOB_RATE = _gnucash_core_c.JOB_RATE

JOB_OWNER = _gnucash_core_c.JOB_OWNER

Q_JOB_OWNER = _gnucash_core_c.Q_JOB_OWNER

JOB_ACTIVE = _gnucash_core_c.JOB_ACTIVE

GNC_PAYMENT_CASH = _gnucash_core_c.GNC_PAYMENT_CASH

GNC_PAYMENT_CARD = _gnucash_core_c.GNC_PAYMENT_CARD

GNC_DISC_PRETAX = _gnucash_core_c.GNC_DISC_PRETAX

GNC_DISC_SAMETIME = _gnucash_core_c.GNC_DISC_SAMETIME

GNC_DISC_POSTTAX = _gnucash_core_c.GNC_DISC_POSTTAX

GNC_ID_ENTRY = _gnucash_core_c.GNC_ID_ENTRY


def gnc_entry_get_type() -> "GType":
    r"""gnc_entry_get_type() -> GType"""
    return _gnucash_core_c.gnc_entry_get_type()

def gncEntryDiscountHowToString(how: "GncDiscountHow") -> "char const *":
    r"""gncEntryDiscountHowToString(GncDiscountHow how) -> char const *"""
    return _gnucash_core_c.gncEntryDiscountHowToString(how)

def gncEntryDiscountStringToHow(str: "char const *", how: "GncDiscountHow *") -> "gboolean":
    r"""gncEntryDiscountStringToHow(char const * str, GncDiscountHow * how) -> gboolean"""
    return _gnucash_core_c.gncEntryDiscountStringToHow(str, how)

def gncEntryPaymentTypeToString(type: "GncEntryPaymentType") -> "char const *":
    r"""gncEntryPaymentTypeToString(GncEntryPaymentType type) -> char const *"""
    return _gnucash_core_c.gncEntryPaymentTypeToString(type)

def gncEntryPaymentStringToType(str: "char const *", type: "GncEntryPaymentType *") -> "gboolean":
    r"""gncEntryPaymentStringToType(char const * str, GncEntryPaymentType * type) -> gboolean"""
    return _gnucash_core_c.gncEntryPaymentStringToType(str, type)

def gncEntryCreate(book: "QofBook *") -> "GncEntry *":
    r"""gncEntryCreate(QofBook * book) -> GncEntry *"""
    return _gnucash_core_c.gncEntryCreate(book)

def gncEntryDestroy(entry: "GncEntry *") -> "void":
    r"""gncEntryDestroy(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryDestroy(entry)

def gncEntrySetDateGDate(entry: "GncEntry *", date: "GDate const *") -> "void":
    r"""gncEntrySetDateGDate(GncEntry * entry, GDate const * date)"""
    return _gnucash_core_c.gncEntrySetDateGDate(entry, date)

def gncEntrySetDate(entry: "GncEntry *", date: "time64") -> "void":
    r"""gncEntrySetDate(GncEntry * entry, time64 date)"""
    return _gnucash_core_c.gncEntrySetDate(entry, date)

def gncEntrySetDateEntered(entry: "GncEntry *", date: "time64") -> "void":
    r"""gncEntrySetDateEntered(GncEntry * entry, time64 date)"""
    return _gnucash_core_c.gncEntrySetDateEntered(entry, date)

def gncEntrySetDescription(entry: "GncEntry *", desc: "char const *") -> "void":
    r"""gncEntrySetDescription(GncEntry * entry, char const * desc)"""
    return _gnucash_core_c.gncEntrySetDescription(entry, desc)

def gncEntrySetAction(entry: "GncEntry *", action: "char const *") -> "void":
    r"""gncEntrySetAction(GncEntry * entry, char const * action)"""
    return _gnucash_core_c.gncEntrySetAction(entry, action)

def gncEntrySetNotes(entry: "GncEntry *", notes: "char const *") -> "void":
    r"""gncEntrySetNotes(GncEntry * entry, char const * notes)"""
    return _gnucash_core_c.gncEntrySetNotes(entry, notes)

def gncEntrySetQuantity(entry: "GncEntry *", quantity: "_gnc_numeric") -> "void":
    r"""gncEntrySetQuantity(GncEntry * entry, _gnc_numeric quantity)"""
    return _gnucash_core_c.gncEntrySetQuantity(entry, quantity)

def gncEntrySetDocQuantity(entry: "GncEntry *", quantity: "_gnc_numeric", is_cn: "gboolean") -> "void":
    r"""gncEntrySetDocQuantity(GncEntry * entry, _gnc_numeric quantity, gboolean is_cn)"""
    return _gnucash_core_c.gncEntrySetDocQuantity(entry, quantity, is_cn)

def gncEntrySetInvAccount(entry: "GncEntry *", acc: "Account *") -> "void":
    r"""gncEntrySetInvAccount(GncEntry * entry, Account * acc)"""
    return _gnucash_core_c.gncEntrySetInvAccount(entry, acc)

def gncEntrySetInvPrice(entry: "GncEntry *", price: "_gnc_numeric") -> "void":
    r"""gncEntrySetInvPrice(GncEntry * entry, _gnc_numeric price)"""
    return _gnucash_core_c.gncEntrySetInvPrice(entry, price)

def gncEntrySetInvTaxable(entry: "GncEntry *", taxable: "gboolean") -> "void":
    r"""gncEntrySetInvTaxable(GncEntry * entry, gboolean taxable)"""
    return _gnucash_core_c.gncEntrySetInvTaxable(entry, taxable)

def gncEntrySetInvTaxIncluded(entry: "GncEntry *", tax_included: "gboolean") -> "void":
    r"""gncEntrySetInvTaxIncluded(GncEntry * entry, gboolean tax_included)"""
    return _gnucash_core_c.gncEntrySetInvTaxIncluded(entry, tax_included)

def gncEntrySetInvTaxTable(entry: "GncEntry *", table: "GncTaxTable *") -> "void":
    r"""gncEntrySetInvTaxTable(GncEntry * entry, GncTaxTable * table)"""
    return _gnucash_core_c.gncEntrySetInvTaxTable(entry, table)

def gncEntrySetInvDiscount(entry: "GncEntry *", discount: "_gnc_numeric") -> "void":
    r"""gncEntrySetInvDiscount(GncEntry * entry, _gnc_numeric discount)"""
    return _gnucash_core_c.gncEntrySetInvDiscount(entry, discount)

def gncEntrySetInvDiscountType(entry: "GncEntry *", type: "GncAmountType") -> "void":
    r"""gncEntrySetInvDiscountType(GncEntry * entry, GncAmountType type)"""
    return _gnucash_core_c.gncEntrySetInvDiscountType(entry, type)

def gncEntrySetInvDiscountHow(entry: "GncEntry *", how: "GncDiscountHow") -> "void":
    r"""gncEntrySetInvDiscountHow(GncEntry * entry, GncDiscountHow how)"""
    return _gnucash_core_c.gncEntrySetInvDiscountHow(entry, how)

def qofEntrySetInvDiscType(entry: "GncEntry *", type: "char const *") -> "void":
    r"""qofEntrySetInvDiscType(GncEntry * entry, char const * type)"""
    return _gnucash_core_c.qofEntrySetInvDiscType(entry, type)

def qofEntrySetInvDiscHow(entry: "GncEntry *", type: "char const *") -> "void":
    r"""qofEntrySetInvDiscHow(GncEntry * entry, char const * type)"""
    return _gnucash_core_c.qofEntrySetInvDiscHow(entry, type)

def gncEntrySetBillAccount(entry: "GncEntry *", acc: "Account *") -> "void":
    r"""gncEntrySetBillAccount(GncEntry * entry, Account * acc)"""
    return _gnucash_core_c.gncEntrySetBillAccount(entry, acc)

def gncEntrySetBillPrice(entry: "GncEntry *", price: "_gnc_numeric") -> "void":
    r"""gncEntrySetBillPrice(GncEntry * entry, _gnc_numeric price)"""
    return _gnucash_core_c.gncEntrySetBillPrice(entry, price)

def gncEntrySetBillTaxable(entry: "GncEntry *", taxable: "gboolean") -> "void":
    r"""gncEntrySetBillTaxable(GncEntry * entry, gboolean taxable)"""
    return _gnucash_core_c.gncEntrySetBillTaxable(entry, taxable)

def gncEntrySetBillTaxIncluded(entry: "GncEntry *", tax_included: "gboolean") -> "void":
    r"""gncEntrySetBillTaxIncluded(GncEntry * entry, gboolean tax_included)"""
    return _gnucash_core_c.gncEntrySetBillTaxIncluded(entry, tax_included)

def gncEntrySetBillTaxTable(entry: "GncEntry *", table: "GncTaxTable *") -> "void":
    r"""gncEntrySetBillTaxTable(GncEntry * entry, GncTaxTable * table)"""
    return _gnucash_core_c.gncEntrySetBillTaxTable(entry, table)

def gncEntrySetBillable(entry: "GncEntry *", billable: "gboolean") -> "void":
    r"""gncEntrySetBillable(GncEntry * entry, gboolean billable)"""
    return _gnucash_core_c.gncEntrySetBillable(entry, billable)

def gncEntrySetBillTo(entry: "GncEntry *", billto: "GncOwner *") -> "void":
    r"""gncEntrySetBillTo(GncEntry * entry, GncOwner * billto)"""
    return _gnucash_core_c.gncEntrySetBillTo(entry, billto)

def gncEntrySetBillPayment(entry: "GncEntry *", type: "GncEntryPaymentType") -> "void":
    r"""gncEntrySetBillPayment(GncEntry * entry, GncEntryPaymentType type)"""
    return _gnucash_core_c.gncEntrySetBillPayment(entry, type)

def gncEntryGetDateGDate(entry: "GncEntry const *") -> "GDate":
    r"""gncEntryGetDateGDate(GncEntry const * entry) -> GDate"""
    return _gnucash_core_c.gncEntryGetDateGDate(entry)

def gncEntryGetDate(entry: "GncEntry const *") -> "time64":
    r"""gncEntryGetDate(GncEntry const * entry) -> time64"""
    return _gnucash_core_c.gncEntryGetDate(entry)

def gncEntryGetDateEntered(entry: "GncEntry const *") -> "time64":
    r"""gncEntryGetDateEntered(GncEntry const * entry) -> time64"""
    return _gnucash_core_c.gncEntryGetDateEntered(entry)

def gncEntryGetDescription(entry: "GncEntry const *") -> "char const *":
    r"""gncEntryGetDescription(GncEntry const * entry) -> char const *"""
    return _gnucash_core_c.gncEntryGetDescription(entry)

def gncEntryGetAction(entry: "GncEntry const *") -> "char const *":
    r"""gncEntryGetAction(GncEntry const * entry) -> char const *"""
    return _gnucash_core_c.gncEntryGetAction(entry)

def gncEntryGetNotes(notes: "GncEntry const *") -> "char const *":
    r"""gncEntryGetNotes(GncEntry const * notes) -> char const *"""
    return _gnucash_core_c.gncEntryGetNotes(notes)

def gncEntryGetQuantity(entry: "GncEntry const *") -> "gnc_numeric":
    r"""gncEntryGetQuantity(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetQuantity(entry)

def gncEntryGetDocQuantity(entry: "GncEntry const *", is_cn: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetDocQuantity(GncEntry const * entry, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocQuantity(entry, is_cn)

def gncEntryGetInvAccount(entry: "GncEntry const *") -> "Account *":
    r"""gncEntryGetInvAccount(GncEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncEntryGetInvAccount(entry)

def gncEntryGetInvPrice(entry: "GncEntry const *") -> "gnc_numeric":
    r"""gncEntryGetInvPrice(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetInvPrice(entry)

def gncEntryGetPrice(entry: "GncEntry const *", cust_doc: "gboolean const", net: "gboolean const") -> "gnc_numeric":
    r"""gncEntryGetPrice(GncEntry const * entry, gboolean const cust_doc, gboolean const net) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetPrice(entry, cust_doc, net)

def gncEntryGetInvDiscount(entry: "GncEntry const *") -> "gnc_numeric":
    r"""gncEntryGetInvDiscount(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetInvDiscount(entry)

def gncEntryGetInvDiscountType(entry: "GncEntry const *") -> "GncAmountType":
    r"""gncEntryGetInvDiscountType(GncEntry const * entry) -> GncAmountType"""
    return _gnucash_core_c.gncEntryGetInvDiscountType(entry)

def gncEntryGetInvDiscountHow(entry: "GncEntry const *") -> "GncDiscountHow":
    r"""gncEntryGetInvDiscountHow(GncEntry const * entry) -> GncDiscountHow"""
    return _gnucash_core_c.gncEntryGetInvDiscountHow(entry)

def qofEntryGetInvDiscType(entry: "GncEntry const *") -> "char *":
    r"""qofEntryGetInvDiscType(GncEntry const * entry) -> char *"""
    return _gnucash_core_c.qofEntryGetInvDiscType(entry)

def qofEntryGetInvDiscHow(entry: "GncEntry const *") -> "char *":
    r"""qofEntryGetInvDiscHow(GncEntry const * entry) -> char *"""
    return _gnucash_core_c.qofEntryGetInvDiscHow(entry)

def gncEntryGetInvTaxable(entry: "GncEntry const *") -> "gboolean":
    r"""gncEntryGetInvTaxable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetInvTaxable(entry)

def gncEntryGetInvTaxIncluded(entry: "GncEntry const *") -> "gboolean":
    r"""gncEntryGetInvTaxIncluded(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetInvTaxIncluded(entry)

def gncEntryGetInvTaxTable(entry: "GncEntry const *") -> "GncTaxTable *":
    r"""gncEntryGetInvTaxTable(GncEntry const * entry) -> GncTaxTable *"""
    return _gnucash_core_c.gncEntryGetInvTaxTable(entry)

def gncEntryGetBillAccount(entry: "GncEntry const *") -> "Account *":
    r"""gncEntryGetBillAccount(GncEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncEntryGetBillAccount(entry)

def gncEntryGetBillPrice(entry: "GncEntry const *") -> "gnc_numeric":
    r"""gncEntryGetBillPrice(GncEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBillPrice(entry)

def gncEntryGetBillTaxable(entry: "GncEntry const *") -> "gboolean":
    r"""gncEntryGetBillTaxable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillTaxable(entry)

def gncEntryGetBillTaxIncluded(entry: "GncEntry const *") -> "gboolean":
    r"""gncEntryGetBillTaxIncluded(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillTaxIncluded(entry)

def gncEntryGetBillTaxTable(entry: "GncEntry const *") -> "GncTaxTable *":
    r"""gncEntryGetBillTaxTable(GncEntry const * entry) -> GncTaxTable *"""
    return _gnucash_core_c.gncEntryGetBillTaxTable(entry)

def gncEntryGetBillable(entry: "GncEntry const *") -> "gboolean":
    r"""gncEntryGetBillable(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryGetBillable(entry)

def gncEntryGetBillTo(entry: "GncEntry *") -> "GncOwner *":
    r"""gncEntryGetBillTo(GncEntry * entry) -> GncOwner *"""
    return _gnucash_core_c.gncEntryGetBillTo(entry)

def gncEntryGetBillPayment(entry: "GncEntry const *") -> "GncEntryPaymentType":
    r"""gncEntryGetBillPayment(GncEntry const * entry) -> GncEntryPaymentType"""
    return _gnucash_core_c.gncEntryGetBillPayment(entry)

def gncEntryCopy(src: "GncEntry const *", dest: "GncEntry *", add_entry: "gboolean") -> "void":
    r"""gncEntryCopy(GncEntry const * src, GncEntry * dest, gboolean add_entry)"""
    return _gnucash_core_c.gncEntryCopy(src, dest, add_entry)

def gncEntryGetDocValue(entry: "GncEntry *", round: "gboolean", is_cust_doc: "gboolean", is_cn: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetDocValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocValue(entry, round, is_cust_doc, is_cn)

def gncEntryGetDocTaxValue(entry: "GncEntry *", round: "gboolean", is_cust_doc: "gboolean", is_cn: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetDocTaxValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocTaxValue(entry, round, is_cust_doc, is_cn)

def gncEntryGetDocTaxValues(entry: "GncEntry *", is_cust_doc: "gboolean", is_cn: "gboolean") -> "AccountValueList *":
    r"""gncEntryGetDocTaxValues(GncEntry * entry, gboolean is_cust_doc, gboolean is_cn) -> AccountValueList *"""
    return _gnucash_core_c.gncEntryGetDocTaxValues(entry, is_cust_doc, is_cn)

def gncEntryGetDocDiscountValue(entry: "GncEntry *", round: "gboolean", is_cust_doc: "gboolean", is_cn: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetDocDiscountValue(GncEntry * entry, gboolean round, gboolean is_cust_doc, gboolean is_cn) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetDocDiscountValue(entry, round, is_cust_doc, is_cn)

def gncEntryGetBalValue(entry: "GncEntry *", round: "gboolean", is_cust_doc: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetBalValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalValue(entry, round, is_cust_doc)

def gncEntryGetBalTaxValue(entry: "GncEntry *", round: "gboolean", is_cust_doc: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetBalTaxValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalTaxValue(entry, round, is_cust_doc)

def gncEntryGetBalTaxValues(entry: "GncEntry *", is_cust_doc: "gboolean") -> "AccountValueList *":
    r"""gncEntryGetBalTaxValues(GncEntry * entry, gboolean is_cust_doc) -> AccountValueList *"""
    return _gnucash_core_c.gncEntryGetBalTaxValues(entry, is_cust_doc)

def gncEntryGetBalDiscountValue(entry: "GncEntry *", round: "gboolean", is_cust_doc: "gboolean") -> "gnc_numeric":
    r"""gncEntryGetBalDiscountValue(GncEntry * entry, gboolean round, gboolean is_cust_doc) -> _gnc_numeric"""
    return _gnucash_core_c.gncEntryGetBalDiscountValue(entry, round, is_cust_doc)

def gncEntryComputeValue(qty: "_gnc_numeric", price: "_gnc_numeric", tax_table: "GncTaxTable const *", tax_included: "gboolean", discount: "_gnc_numeric", discount_type: "GncAmountType", discount_how: "GncDiscountHow", SCU: "int", value: "_gnc_numeric", discount_value: "_gnc_numeric", tax_values: "GList **") -> "void":
    r"""gncEntryComputeValue(_gnc_numeric qty, _gnc_numeric price, GncTaxTable const * tax_table, gboolean tax_included, _gnc_numeric discount, GncAmountType discount_type, GncDiscountHow discount_how, int SCU, _gnc_numeric value, _gnc_numeric discount_value, GList ** tax_values)"""
    return _gnucash_core_c.gncEntryComputeValue(qty, price, tax_table, tax_included, discount, discount_type, discount_how, SCU, value, discount_value, tax_values)

def gncEntryGetOrder(entry: "GncEntry const *") -> "GncOrder *":
    r"""gncEntryGetOrder(GncEntry const * entry) -> GncOrder *"""
    return _gnucash_core_c.gncEntryGetOrder(entry)

def gncEntryGetInvoice(entry: "GncEntry const *") -> "GncInvoice *":
    r"""gncEntryGetInvoice(GncEntry const * entry) -> GncInvoice *"""
    return _gnucash_core_c.gncEntryGetInvoice(entry)

def gncEntryGetBill(entry: "GncEntry const *") -> "GncInvoice *":
    r"""gncEntryGetBill(GncEntry const * entry) -> GncInvoice *"""
    return _gnucash_core_c.gncEntryGetBill(entry)

def gncEntryLookup(book: "QofBook const *", guid: "GncGUID") -> "GncEntry *":
    r"""gncEntryLookup(QofBook const * book, GncGUID guid) -> GncEntry *"""
    return _gnucash_core_c.gncEntryLookup(book, guid)

def gncEntryIsOpen(entry: "GncEntry const *") -> "gboolean":
    r"""gncEntryIsOpen(GncEntry const * entry) -> gboolean"""
    return _gnucash_core_c.gncEntryIsOpen(entry)

def gncEntryBeginEdit(entry: "GncEntry *") -> "void":
    r"""gncEntryBeginEdit(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryBeginEdit(entry)

def gncEntryCommitEdit(entry: "GncEntry *") -> "void":
    r"""gncEntryCommitEdit(GncEntry * entry)"""
    return _gnucash_core_c.gncEntryCommitEdit(entry)

def gncEntryCompare(a: "GncEntry const *", b: "GncEntry const *") -> "int":
    r"""gncEntryCompare(GncEntry const * a, GncEntry const * b) -> int"""
    return _gnucash_core_c.gncEntryCompare(a, b)
ENTRY_DATE = _gnucash_core_c.ENTRY_DATE

ENTRY_DATE_ENTERED = _gnucash_core_c.ENTRY_DATE_ENTERED

ENTRY_DESC = _gnucash_core_c.ENTRY_DESC

ENTRY_ACTION = _gnucash_core_c.ENTRY_ACTION

ENTRY_NOTES = _gnucash_core_c.ENTRY_NOTES

ENTRY_QTY = _gnucash_core_c.ENTRY_QTY

ENTRY_IPRICE = _gnucash_core_c.ENTRY_IPRICE

ENTRY_IACCT = _gnucash_core_c.ENTRY_IACCT

ENTRY_BACCT = _gnucash_core_c.ENTRY_BACCT

ENTRY_BPRICE = _gnucash_core_c.ENTRY_BPRICE

ENTRY_BILLABLE = _gnucash_core_c.ENTRY_BILLABLE

ENTRY_BILLTO = _gnucash_core_c.ENTRY_BILLTO

ENTRY_ORDER = _gnucash_core_c.ENTRY_ORDER

ENTRY_INVOICE = _gnucash_core_c.ENTRY_INVOICE

ENTRY_BILL = _gnucash_core_c.ENTRY_BILL

ENTRY_INV_DISC_TYPE = _gnucash_core_c.ENTRY_INV_DISC_TYPE

ENTRY_INV_DISC_HOW = _gnucash_core_c.ENTRY_INV_DISC_HOW

ENTRY_INV_TAXABLE = _gnucash_core_c.ENTRY_INV_TAXABLE

ENTRY_BILL_TAXABLE = _gnucash_core_c.ENTRY_BILL_TAXABLE

ENTRY_INV_TAX_INC = _gnucash_core_c.ENTRY_INV_TAX_INC

ENTRY_BILL_TAX_INC = _gnucash_core_c.ENTRY_BILL_TAX_INC

ENTRY_INV_DISCOUNT = _gnucash_core_c.ENTRY_INV_DISCOUNT

ENTRY_BILL_PAY_TYPE = _gnucash_core_c.ENTRY_BILL_PAY_TYPE

GNC_AMT_TYPE_VALUE = _gnucash_core_c.GNC_AMT_TYPE_VALUE

GNC_AMT_TYPE_PERCENT = _gnucash_core_c.GNC_AMT_TYPE_PERCENT

GNC_TAXINCLUDED_YES = _gnucash_core_c.GNC_TAXINCLUDED_YES

GNC_TAXINCLUDED_NO = _gnucash_core_c.GNC_TAXINCLUDED_NO

GNC_TAXINCLUDED_USEGLOBAL = _gnucash_core_c.GNC_TAXINCLUDED_USEGLOBAL

GNC_ID_TAXTABLE = _gnucash_core_c.GNC_ID_TAXTABLE


def gnc_taxtable_get_type() -> "GType":
    r"""gnc_taxtable_get_type() -> GType"""
    return _gnucash_core_c.gnc_taxtable_get_type()

def gncAmountTypeToString(type: "GncAmountType") -> "char const *":
    r"""gncAmountTypeToString(GncAmountType type) -> char const *"""
    return _gnucash_core_c.gncAmountTypeToString(type)

def gncAmountStringToType(str: "char const *", type: "GncAmountType *") -> "gboolean":
    r"""gncAmountStringToType(char const * str, GncAmountType * type) -> gboolean"""
    return _gnucash_core_c.gncAmountStringToType(str, type)

def gncTaxIncludedTypeToString(type: "GncTaxIncluded") -> "char const *":
    r"""gncTaxIncludedTypeToString(GncTaxIncluded type) -> char const *"""
    return _gnucash_core_c.gncTaxIncludedTypeToString(type)

def gncTaxIncludedStringToType(str: "char const *", type: "GncTaxIncluded *") -> "gboolean":
    r"""gncTaxIncludedStringToType(char const * str, GncTaxIncluded * type) -> gboolean"""
    return _gnucash_core_c.gncTaxIncludedStringToType(str, type)

def gncTaxTableCreate(book: "QofBook *") -> "GncTaxTable *":
    r"""gncTaxTableCreate(QofBook * book) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableCreate(book)

def gncTaxTableDestroy(table: "GncTaxTable *") -> "void":
    r"""gncTaxTableDestroy(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableDestroy(table)

def gncTaxTableEntryCreate() -> "GncTaxTableEntry *":
    r"""gncTaxTableEntryCreate() -> GncTaxTableEntry *"""
    return _gnucash_core_c.gncTaxTableEntryCreate()

def gncTaxTableEntryDestroy(entry: "GncTaxTableEntry *") -> "void":
    r"""gncTaxTableEntryDestroy(GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableEntryDestroy(entry)

def gncTaxTableSetName(table: "GncTaxTable *", name: "char const *") -> "void":
    r"""gncTaxTableSetName(GncTaxTable * table, char const * name)"""
    return _gnucash_core_c.gncTaxTableSetName(table, name)

def gncTaxTableIncRef(table: "GncTaxTable *") -> "void":
    r"""gncTaxTableIncRef(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableIncRef(table)

def gncTaxTableDecRef(table: "GncTaxTable *") -> "void":
    r"""gncTaxTableDecRef(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableDecRef(table)

def gncTaxTableEntrySetAccount(entry: "GncTaxTableEntry *", account: "Account *") -> "void":
    r"""gncTaxTableEntrySetAccount(GncTaxTableEntry * entry, Account * account)"""
    return _gnucash_core_c.gncTaxTableEntrySetAccount(entry, account)

def gncTaxTableEntrySetType(entry: "GncTaxTableEntry *", type: "GncAmountType") -> "void":
    r"""gncTaxTableEntrySetType(GncTaxTableEntry * entry, GncAmountType type)"""
    return _gnucash_core_c.gncTaxTableEntrySetType(entry, type)

def gncTaxTableEntrySetAmount(entry: "GncTaxTableEntry *", amount: "_gnc_numeric") -> "void":
    r"""gncTaxTableEntrySetAmount(GncTaxTableEntry * entry, _gnc_numeric amount)"""
    return _gnucash_core_c.gncTaxTableEntrySetAmount(entry, amount)

def gncTaxTableAddEntry(table: "GncTaxTable *", entry: "GncTaxTableEntry *") -> "void":
    r"""gncTaxTableAddEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableAddEntry(table, entry)

def gncTaxTableRemoveEntry(table: "GncTaxTable *", entry: "GncTaxTableEntry *") -> "void":
    r"""gncTaxTableRemoveEntry(GncTaxTable * table, GncTaxTableEntry * entry)"""
    return _gnucash_core_c.gncTaxTableRemoveEntry(table, entry)

def gncTaxTableChanged(table: "GncTaxTable *") -> "void":
    r"""gncTaxTableChanged(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableChanged(table)

def gncTaxTableBeginEdit(table: "GncTaxTable *") -> "void":
    r"""gncTaxTableBeginEdit(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableBeginEdit(table)

def gncTaxTableCommitEdit(table: "GncTaxTable *") -> "void":
    r"""gncTaxTableCommitEdit(GncTaxTable * table)"""
    return _gnucash_core_c.gncTaxTableCommitEdit(table)

def gncTaxTableEqual(a: "GncTaxTable const *", b: "GncTaxTable const *") -> "gboolean":
    r"""gncTaxTableEqual(GncTaxTable const * a, GncTaxTable const * b) -> gboolean"""
    return _gnucash_core_c.gncTaxTableEqual(a, b)

def gncTaxTableLookup(book: "QofBook const *", guid: "GncGUID") -> "GncTaxTable *":
    r"""gncTaxTableLookup(QofBook const * book, GncGUID guid) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableLookup(book, guid)

def gncTaxTableLookupByName(book: "QofBook *", name: "char const *") -> "GncTaxTable *":
    r"""gncTaxTableLookupByName(QofBook * book, char const * name) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableLookupByName(book, name)

def gncTaxTableGetDefault(book: "QofBook *", type: "GncOwnerType") -> "GncTaxTable *":
    r"""gncTaxTableGetDefault(QofBook * book, GncOwnerType type) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableGetDefault(book, type)

def gncTaxTableGetTables(book: "QofBook *") -> "GncTaxTableList *":
    r"""gncTaxTableGetTables(QofBook * book) -> GncTaxTableList *"""
    return _gnucash_core_c.gncTaxTableGetTables(book)

def gncTaxTableGetName(table: "GncTaxTable const *") -> "char const *":
    r"""gncTaxTableGetName(GncTaxTable const * table) -> char const *"""
    return _gnucash_core_c.gncTaxTableGetName(table)

def gncTaxTableGetParent(table: "GncTaxTable const *") -> "GncTaxTable *":
    r"""gncTaxTableGetParent(GncTaxTable const * table) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableGetParent(table)

def gncTaxTableReturnChild(table: "GncTaxTable *", make_new: "gboolean") -> "GncTaxTable *":
    r"""gncTaxTableReturnChild(GncTaxTable * table, gboolean make_new) -> GncTaxTable *"""
    return _gnucash_core_c.gncTaxTableReturnChild(table, make_new)

def gncTaxTableGetEntries(table: "GncTaxTable const *") -> "GncTaxTableEntryList *":
    r"""gncTaxTableGetEntries(GncTaxTable const * table) -> GncTaxTableEntryList *"""
    return _gnucash_core_c.gncTaxTableGetEntries(table)

def gncTaxTableGetRefcount(table: "GncTaxTable const *") -> "gint64":
    r"""gncTaxTableGetRefcount(GncTaxTable const * table) -> gint64"""
    return _gnucash_core_c.gncTaxTableGetRefcount(table)

def gncTaxTableLastModifiedSecs(table: "GncTaxTable const *") -> "time64":
    r"""gncTaxTableLastModifiedSecs(GncTaxTable const * table) -> time64"""
    return _gnucash_core_c.gncTaxTableLastModifiedSecs(table)

def gncTaxTableEntryGetAccount(entry: "GncTaxTableEntry const *") -> "Account *":
    r"""gncTaxTableEntryGetAccount(GncTaxTableEntry const * entry) -> Account *"""
    return _gnucash_core_c.gncTaxTableEntryGetAccount(entry)

def gncTaxTableEntryGetType(entry: "GncTaxTableEntry const *") -> "GncAmountType":
    r"""gncTaxTableEntryGetType(GncTaxTableEntry const * entry) -> GncAmountType"""
    return _gnucash_core_c.gncTaxTableEntryGetType(entry)

def gncTaxTableEntryGetAmount(entry: "GncTaxTableEntry const *") -> "gnc_numeric":
    r"""gncTaxTableEntryGetAmount(GncTaxTableEntry const * entry) -> _gnc_numeric"""
    return _gnucash_core_c.gncTaxTableEntryGetAmount(entry)

def gncTaxTableCompare(a: "GncTaxTable const *", b: "GncTaxTable const *") -> "int":
    r"""gncTaxTableCompare(GncTaxTable const * a, GncTaxTable const * b) -> int"""
    return _gnucash_core_c.gncTaxTableCompare(a, b)

def gncTaxTableEntryCompare(a: "GncTaxTableEntry const *", b: "GncTaxTableEntry const *") -> "int":
    r"""gncTaxTableEntryCompare(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> int"""
    return _gnucash_core_c.gncTaxTableEntryCompare(a, b)

def gncTaxTableEntryEqual(a: "GncTaxTableEntry const *", b: "GncTaxTableEntry const *") -> "gboolean":
    r"""gncTaxTableEntryEqual(GncTaxTableEntry const * a, GncTaxTableEntry const * b) -> gboolean"""
    return _gnucash_core_c.gncTaxTableEntryEqual(a, b)
class _gncAccountValue(object):
    r"""Proxy of C _gncAccountValue struct."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    account = property(_gnucash_core_c._gncAccountValue_account_get, _gnucash_core_c._gncAccountValue_account_set, doc=r"""account : p.Account""")
    value = property(_gnucash_core_c._gncAccountValue_value_get, _gnucash_core_c._gncAccountValue_value_set, doc=r"""value : gnc_numeric""")

    def __init__(self):
        r"""__init__(_gncAccountValue self) -> _gncAccountValue"""
        _gnucash_core_c._gncAccountValue_swiginit(self, _gnucash_core_c.new__gncAccountValue())
    __swig_destroy__ = _gnucash_core_c.delete__gncAccountValue

# Register _gncAccountValue in _gnucash_core_c:
_gnucash_core_c._gncAccountValue_swigregister(_gncAccountValue)


def gncAccountValueAdd(list: "GList *", acc: "Account *", value: "_gnc_numeric") -> "GList *":
    r"""gncAccountValueAdd(GList * list, Account * acc, _gnc_numeric value) -> GList *"""
    return _gnucash_core_c.gncAccountValueAdd(list, acc, value)

def gncAccountValueAddList(l1: "GList *", l2: "GList *") -> "GList *":
    r"""gncAccountValueAddList(GList * l1, GList * l2) -> GList *"""
    return _gnucash_core_c.gncAccountValueAddList(l1, l2)

def gncAccountValueTotal(list: "GList *") -> "gnc_numeric":
    r"""gncAccountValueTotal(GList * list) -> _gnc_numeric"""
    return _gnucash_core_c.gncAccountValueTotal(list)

def gncAccountValueDestroy(list: "GList *") -> "void":
    r"""gncAccountValueDestroy(GList * list)"""
    return _gnucash_core_c.gncAccountValueDestroy(list)
GNC_TT_NAME = _gnucash_core_c.GNC_TT_NAME

GNC_TT_REFCOUNT = _gnucash_core_c.GNC_TT_REFCOUNT


def gnc_search_customer_on_id(book: "QofBook *", id: "gchar const *") -> "GncCustomer *":
    r"""gnc_search_customer_on_id(QofBook * book, gchar const * id) -> GncCustomer *"""
    return _gnucash_core_c.gnc_search_customer_on_id(book, id)

def gnc_search_invoice_on_id(book: "QofBook *", id: "gchar const *") -> "GncInvoice *":
    r"""gnc_search_invoice_on_id(QofBook * book, gchar const * id) -> GncInvoice *"""
    return _gnucash_core_c.gnc_search_invoice_on_id(book, id)

def gnc_search_bill_on_id(book: "QofBook *", id: "gchar const *") -> "GncInvoice *":
    r"""gnc_search_bill_on_id(QofBook * book, gchar const * id) -> GncInvoice *"""
    return _gnucash_core_c.gnc_search_bill_on_id(book, id)

def gnc_search_vendor_on_id(book: "QofBook *", id: "gchar const *") -> "GncVendor *":
    r"""gnc_search_vendor_on_id(QofBook * book, gchar const * id) -> GncVendor *"""
    return _gnucash_core_c.gnc_search_vendor_on_id(book, id)

def gnc_price_get_type() -> "GType":
    r"""gnc_price_get_type() -> GType"""
    return _gnucash_core_c.gnc_price_get_type()

def gnc_pricedb_get_type() -> "GType":
    r"""gnc_pricedb_get_type() -> GType"""
    return _gnucash_core_c.gnc_pricedb_get_type()
PRICE_SOURCE_EDIT_DLG = _gnucash_core_c.PRICE_SOURCE_EDIT_DLG

PRICE_SOURCE_FQ = _gnucash_core_c.PRICE_SOURCE_FQ

PRICE_SOURCE_USER_PRICE = _gnucash_core_c.PRICE_SOURCE_USER_PRICE

PRICE_SOURCE_XFER_DLG_VAL = _gnucash_core_c.PRICE_SOURCE_XFER_DLG_VAL

PRICE_SOURCE_SPLIT_REG = _gnucash_core_c.PRICE_SOURCE_SPLIT_REG

PRICE_SOURCE_STOCK_SPLIT = _gnucash_core_c.PRICE_SOURCE_STOCK_SPLIT

PRICE_SOURCE_INVOICE = _gnucash_core_c.PRICE_SOURCE_INVOICE

PRICE_SOURCE_TEMP = _gnucash_core_c.PRICE_SOURCE_TEMP

PRICE_SOURCE_INVALID = _gnucash_core_c.PRICE_SOURCE_INVALID

PRICE_TYPE_LAST = _gnucash_core_c.PRICE_TYPE_LAST

PRICE_TYPE_UNK = _gnucash_core_c.PRICE_TYPE_UNK

PRICE_TYPE_TRN = _gnucash_core_c.PRICE_TYPE_TRN


def gnc_price_create(book: "QofBook *") -> "GNCPrice *":
    r"""gnc_price_create(QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_create(book)

def gnc_price_clone(p: "GNCPrice *", book: "QofBook *") -> "GNCPrice *":
    r"""gnc_price_clone(GNCPrice * p, QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_clone(p, book)

def gnc_price_invert(p: "GNCPrice *") -> "GNCPrice *":
    r"""gnc_price_invert(GNCPrice * p) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_invert(p)

def gnc_price_ref(p: "GNCPrice *") -> "void":
    r"""gnc_price_ref(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_ref(p)

def gnc_price_unref(p: "GNCPrice *") -> "void":
    r"""gnc_price_unref(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_unref(p)

def gnc_price_begin_edit(p: "GNCPrice *") -> "void":
    r"""gnc_price_begin_edit(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_begin_edit(p)

def gnc_price_commit_edit(p: "GNCPrice *") -> "void":
    r"""gnc_price_commit_edit(GNCPrice * p)"""
    return _gnucash_core_c.gnc_price_commit_edit(p)

def gnc_price_set_commodity(p: "GNCPrice *", c: "gnc_commodity *") -> "void":
    r"""gnc_price_set_commodity(GNCPrice * p, gnc_commodity * c)"""
    return _gnucash_core_c.gnc_price_set_commodity(p, c)

def gnc_price_set_currency(p: "GNCPrice *", c: "gnc_commodity *") -> "void":
    r"""gnc_price_set_currency(GNCPrice * p, gnc_commodity * c)"""
    return _gnucash_core_c.gnc_price_set_currency(p, c)

def gnc_price_set_time64(p: "GNCPrice *", t: "time64") -> "void":
    r"""gnc_price_set_time64(GNCPrice * p, time64 t)"""
    return _gnucash_core_c.gnc_price_set_time64(p, t)

def gnc_price_set_source(p: "GNCPrice *", source: "PriceSource") -> "void":
    r"""gnc_price_set_source(GNCPrice * p, PriceSource source)"""
    return _gnucash_core_c.gnc_price_set_source(p, source)

def gnc_price_set_source_string(p: "GNCPrice *", s: "char const *") -> "void":
    r"""gnc_price_set_source_string(GNCPrice * p, char const * s)"""
    return _gnucash_core_c.gnc_price_set_source_string(p, s)

def gnc_price_set_typestr(p: "GNCPrice *", type: "char const *") -> "void":
    r"""gnc_price_set_typestr(GNCPrice * p, char const * type)"""
    return _gnucash_core_c.gnc_price_set_typestr(p, type)

def gnc_price_set_value(p: "GNCPrice *", value: "_gnc_numeric") -> "void":
    r"""gnc_price_set_value(GNCPrice * p, _gnc_numeric value)"""
    return _gnucash_core_c.gnc_price_set_value(p, value)

def gnc_price_lookup(guid: "GncGUID", book: "QofBook *") -> "GNCPrice *":
    r"""gnc_price_lookup(GncGUID guid, QofBook * book) -> GNCPrice *"""
    return _gnucash_core_c.gnc_price_lookup(guid, book)

def gnc_price_get_commodity(p: "GNCPrice const *") -> "gnc_commodity *":
    r"""gnc_price_get_commodity(GNCPrice const * p) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_price_get_commodity(p)

def gnc_price_get_currency(p: "GNCPrice const *") -> "gnc_commodity *":
    r"""gnc_price_get_currency(GNCPrice const * p) -> gnc_commodity *"""
    return _gnucash_core_c.gnc_price_get_currency(p)

def gnc_price_get_time64(p: "GNCPrice const *") -> "time64":
    r"""gnc_price_get_time64(GNCPrice const * p) -> time64"""
    return _gnucash_core_c.gnc_price_get_time64(p)

def gnc_price_get_source(p: "GNCPrice const *") -> "PriceSource":
    r"""gnc_price_get_source(GNCPrice const * p) -> PriceSource"""
    return _gnucash_core_c.gnc_price_get_source(p)

def gnc_price_get_source_string(p: "GNCPrice const *") -> "char const *":
    r"""gnc_price_get_source_string(GNCPrice const * p) -> char const *"""
    return _gnucash_core_c.gnc_price_get_source_string(p)

def gnc_price_get_typestr(p: "GNCPrice const *") -> "char const *":
    r"""gnc_price_get_typestr(GNCPrice const * p) -> char const *"""
    return _gnucash_core_c.gnc_price_get_typestr(p)

def gnc_price_get_value(p: "GNCPrice const *") -> "gnc_numeric":
    r"""gnc_price_get_value(GNCPrice const * p) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_price_get_value(p)

def gnc_price_equal(p1: "GNCPrice const *", p2: "GNCPrice const *") -> "gboolean":
    r"""gnc_price_equal(GNCPrice const * p1, GNCPrice const * p2) -> gboolean"""
    return _gnucash_core_c.gnc_price_equal(p1, p2)

def gnc_price_print(db: "GNCPrice *", f: "FILE *", indent: "int") -> "void":
    r"""gnc_price_print(GNCPrice * db, FILE * f, int indent)"""
    return _gnucash_core_c.gnc_price_print(db, f, indent)
CURRENCY_DENOM = _gnucash_core_c.CURRENCY_DENOM

COMMODITY_DENOM_MULT = _gnucash_core_c.COMMODITY_DENOM_MULT


def gnc_price_list_insert(prices: "PriceList **", p: "GNCPrice *", check_dupl: "gboolean") -> "gboolean":
    r"""gnc_price_list_insert(PriceList ** prices, GNCPrice * p, gboolean check_dupl) -> gboolean"""
    return _gnucash_core_c.gnc_price_list_insert(prices, p, check_dupl)

def gnc_price_list_remove(prices: "PriceList **", p: "GNCPrice *") -> "gboolean":
    r"""gnc_price_list_remove(PriceList ** prices, GNCPrice * p) -> gboolean"""
    return _gnucash_core_c.gnc_price_list_remove(prices, p)

def gnc_price_list_destroy(prices: "PriceList *") -> "void":
    r"""gnc_price_list_destroy(PriceList * prices)"""
    return _gnucash_core_c.gnc_price_list_destroy(prices)

def gnc_price_list_equal(prices1: "PriceList *", prices2: "PriceList *") -> "gboolean":
    r"""gnc_price_list_equal(PriceList * prices1, PriceList * prices2) -> gboolean"""
    return _gnucash_core_c.gnc_price_list_equal(prices1, prices2)

def gnc_pricedb_get_db(book: "QofBook *") -> "GNCPriceDB *":
    r"""gnc_pricedb_get_db(QofBook * book) -> GNCPriceDB *"""
    return _gnucash_core_c.gnc_pricedb_get_db(book)

def gnc_collection_get_pricedb(col: "QofCollection *") -> "GNCPriceDB *":
    r"""gnc_collection_get_pricedb(QofCollection * col) -> GNCPriceDB *"""
    return _gnucash_core_c.gnc_collection_get_pricedb(col)

def gnc_pricedb_destroy(db: "GNCPriceDB *") -> "void":
    r"""gnc_pricedb_destroy(GNCPriceDB * db)"""
    return _gnucash_core_c.gnc_pricedb_destroy(db)

def gnc_pricedb_begin_edit(arg1: "GNCPriceDB *") -> "void":
    r"""gnc_pricedb_begin_edit(GNCPriceDB * arg1)"""
    return _gnucash_core_c.gnc_pricedb_begin_edit(arg1)

def gnc_pricedb_commit_edit(arg1: "GNCPriceDB *") -> "void":
    r"""gnc_pricedb_commit_edit(GNCPriceDB * arg1)"""
    return _gnucash_core_c.gnc_pricedb_commit_edit(arg1)

def gnc_pricedb_set_bulk_update(db: "GNCPriceDB *", bulk_update: "gboolean") -> "void":
    r"""gnc_pricedb_set_bulk_update(GNCPriceDB * db, gboolean bulk_update)"""
    return _gnucash_core_c.gnc_pricedb_set_bulk_update(db, bulk_update)

def gnc_pricedb_add_price(db: "GNCPriceDB *", p: "GNCPrice *") -> "gboolean":
    r"""gnc_pricedb_add_price(GNCPriceDB * db, GNCPrice * p) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_add_price(db, p)

def gnc_pricedb_remove_price(db: "GNCPriceDB *", p: "GNCPrice *") -> "gboolean":
    r"""gnc_pricedb_remove_price(GNCPriceDB * db, GNCPrice * p) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_remove_price(db, p)
PRICE_REMOVE_SOURCE_FQ = _gnucash_core_c.PRICE_REMOVE_SOURCE_FQ

PRICE_REMOVE_SOURCE_USER = _gnucash_core_c.PRICE_REMOVE_SOURCE_USER

PRICE_REMOVE_SOURCE_APP = _gnucash_core_c.PRICE_REMOVE_SOURCE_APP

PRICE_REMOVE_SOURCE_COMM = _gnucash_core_c.PRICE_REMOVE_SOURCE_COMM

PRICE_REMOVE_KEEP_NONE = _gnucash_core_c.PRICE_REMOVE_KEEP_NONE

PRICE_REMOVE_KEEP_LAST_WEEKLY = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_WEEKLY

PRICE_REMOVE_KEEP_LAST_MONTHLY = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_MONTHLY

PRICE_REMOVE_KEEP_LAST_QUARTERLY = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_QUARTERLY

PRICE_REMOVE_KEEP_LAST_PERIOD = _gnucash_core_c.PRICE_REMOVE_KEEP_LAST_PERIOD

PRICE_REMOVE_KEEP_SCALED = _gnucash_core_c.PRICE_REMOVE_KEEP_SCALED


def gnc_pricedb_remove_old_prices(db: "GNCPriceDB *", comm_list: "GList *", fiscal_end_date: "GDate *", cutoff: "time64", source: "PriceRemoveSourceFlags", keep: "PriceRemoveKeepOptions") -> "gboolean":
    r"""gnc_pricedb_remove_old_prices(GNCPriceDB * db, GList * comm_list, GDate * fiscal_end_date, time64 cutoff, PriceRemoveSourceFlags source, PriceRemoveKeepOptions keep) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_remove_old_prices(db, comm_list, fiscal_end_date, cutoff, source, keep)

def gnc_pricedb_lookup_latest(db: "GNCPriceDB *", commodity: "gnc_commodity const *", currency: "gnc_commodity const *") -> "GNCPrice *":
    r"""gnc_pricedb_lookup_latest(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest(db, commodity, currency)

def gnc_pricedb_lookup_latest_any_currency(db: "GNCPriceDB *", commodity: "gnc_commodity const *") -> "PriceList *":
    r"""gnc_pricedb_lookup_latest_any_currency(GNCPriceDB * db, gnc_commodity const * commodity) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest_any_currency(db, commodity)

def gnc_pricedb_has_prices(db: "GNCPriceDB *", commodity: "gnc_commodity const *", currency: "gnc_commodity const *") -> "gboolean":
    r"""gnc_pricedb_has_prices(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_has_prices(db, commodity, currency)

def gnc_pricedb_get_prices(db: "GNCPriceDB *", commodity: "gnc_commodity const *", currency: "gnc_commodity const *") -> "PriceList *":
    r"""gnc_pricedb_get_prices(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_get_prices(db, commodity, currency)

def gnc_pricedb_lookup_at_time64(db: "GNCPriceDB *", commodity: "gnc_commodity const *", currency: "gnc_commodity const *", t: "time64") -> "GNCPrice *":
    r"""gnc_pricedb_lookup_at_time64(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_at_time64(db, commodity, currency, t)

def gnc_pricedb_lookup_day_t64(db: "GNCPriceDB *", commodity: "gnc_commodity const *", currency: "gnc_commodity const *", t: "time64") -> "GNCPrice *":
    r"""gnc_pricedb_lookup_day_t64(GNCPriceDB * db, gnc_commodity const * commodity, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_day_t64(db, commodity, currency, t)

def gnc_pricedb_lookup_nearest_in_time64(db: "GNCPriceDB *", c: "gnc_commodity const *", currency: "gnc_commodity const *", t: "time64") -> "GNCPrice *":
    r"""gnc_pricedb_lookup_nearest_in_time64(GNCPriceDB * db, gnc_commodity const * c, gnc_commodity const * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_nearest_in_time64(db, c, currency, t)

def gnc_pricedb_lookup_nearest_in_time_any_currency_t64(db: "GNCPriceDB *", c: "gnc_commodity const *", t: "time64") -> "PriceList *":
    r"""gnc_pricedb_lookup_nearest_in_time_any_currency_t64(GNCPriceDB * db, gnc_commodity const * c, time64 t) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_nearest_in_time_any_currency_t64(db, c, t)

def gnc_pricedb_lookup_latest_before_t64(db: "GNCPriceDB *", c: "gnc_commodity *", currency: "gnc_commodity *", t: "time64") -> "GNCPrice *":
    r"""gnc_pricedb_lookup_latest_before_t64(GNCPriceDB * db, gnc_commodity * c, gnc_commodity * currency, time64 t) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest_before_t64(db, c, currency, t)

def gnc_pricedb_lookup_latest_before_any_currency_t64(db: "GNCPriceDB *", c: "gnc_commodity const *", t: "time64") -> "PriceList *":
    r"""gnc_pricedb_lookup_latest_before_any_currency_t64(GNCPriceDB * db, gnc_commodity const * c, time64 t) -> PriceList *"""
    return _gnucash_core_c.gnc_pricedb_lookup_latest_before_any_currency_t64(db, c, t)

def gnc_pricedb_convert_balance_latest_price(pdb: "GNCPriceDB *", balance: "_gnc_numeric", balance_currency: "gnc_commodity const *", new_currency: "gnc_commodity const *") -> "gnc_numeric":
    r"""gnc_pricedb_convert_balance_latest_price(GNCPriceDB * pdb, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_convert_balance_latest_price(pdb, balance, balance_currency, new_currency)

def gnc_pricedb_convert_balance_nearest_price_t64(pdb: "GNCPriceDB *", balance: "_gnc_numeric", balance_currency: "gnc_commodity const *", new_currency: "gnc_commodity const *", t: "time64") -> "gnc_numeric":
    r"""gnc_pricedb_convert_balance_nearest_price_t64(GNCPriceDB * pdb, _gnc_numeric balance, gnc_commodity const * balance_currency, gnc_commodity const * new_currency, time64 t) -> _gnc_numeric"""
    return _gnucash_core_c.gnc_pricedb_convert_balance_nearest_price_t64(pdb, balance, balance_currency, new_currency, t)

def gnc_pricedb_foreach_price(db: "GNCPriceDB *", f: "GncPriceForeachFunc", user_data: "gpointer", stable_order: "gboolean") -> "gboolean":
    r"""gnc_pricedb_foreach_price(GNCPriceDB * db, GncPriceForeachFunc f, gpointer user_data, gboolean stable_order) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_foreach_price(db, f, user_data, stable_order)

def gnc_pricedb_num_prices(db: "GNCPriceDB *", c: "gnc_commodity const *") -> "int":
    r"""gnc_pricedb_num_prices(GNCPriceDB * db, gnc_commodity const * c) -> int"""
    return _gnucash_core_c.gnc_pricedb_num_prices(db, c)

def gnc_pricedb_nth_price(db: "GNCPriceDB *", c: "gnc_commodity const *", n: "int const") -> "GNCPrice *":
    r"""gnc_pricedb_nth_price(GNCPriceDB * db, gnc_commodity const * c, int const n) -> GNCPrice *"""
    return _gnucash_core_c.gnc_pricedb_nth_price(db, c, n)

def gnc_pricedb_nth_price_reset_cache(db: "GNCPriceDB *") -> "void":
    r"""gnc_pricedb_nth_price_reset_cache(GNCPriceDB * db)"""
    return _gnucash_core_c.gnc_pricedb_nth_price_reset_cache(db)

def gnc_pricedb_get_num_prices(db: "GNCPriceDB *") -> "guint":
    r"""gnc_pricedb_get_num_prices(GNCPriceDB * db) -> guint"""
    return _gnucash_core_c.gnc_pricedb_get_num_prices(db)

def gnc_pricedb_equal(db1: "GNCPriceDB *", db2: "GNCPriceDB *") -> "gboolean":
    r"""gnc_pricedb_equal(GNCPriceDB * db1, GNCPriceDB * db2) -> gboolean"""
    return _gnucash_core_c.gnc_pricedb_equal(db1, db2)

def gnc_pricedb_print_contents(db: "GNCPriceDB *", f: "FILE *") -> "void":
    r"""gnc_pricedb_print_contents(GNCPriceDB * db, FILE * f)"""
    return _gnucash_core_c.gnc_pricedb_print_contents(db, f)
PRICE_COMMODITY = _gnucash_core_c.PRICE_COMMODITY

PRICE_CURRENCY = _gnucash_core_c.PRICE_CURRENCY

PRICE_DATE = _gnucash_core_c.PRICE_DATE

PRICE_SOURCE = _gnucash_core_c.PRICE_SOURCE

PRICE_TYPE = _gnucash_core_c.PRICE_TYPE

PRICE_VALUE = _gnucash_core_c.PRICE_VALUE


def xaccSplitGetCapGains(arg1: "Split *") -> "gnc_numeric":
    r"""xaccSplitGetCapGains(Split * arg1) -> _gnc_numeric"""
    return _gnucash_core_c.xaccSplitGetCapGains(arg1)

def xaccAccountHasTrades(arg1: "Account const *") -> "gboolean":
    r"""xaccAccountHasTrades(Account const * arg1) -> gboolean"""
    return _gnucash_core_c.xaccAccountHasTrades(arg1)

def xaccAccountFindEarliestOpenLot(acc: "Account *", sign: "_gnc_numeric", currency: "gnc_commodity *") -> "GNCLot *":
    r"""xaccAccountFindEarliestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
    return _gnucash_core_c.xaccAccountFindEarliestOpenLot(acc, sign, currency)

def xaccAccountFindLatestOpenLot(acc: "Account *", sign: "_gnc_numeric", currency: "gnc_commodity *") -> "GNCLot *":
    r"""xaccAccountFindLatestOpenLot(Account * acc, _gnc_numeric sign, gnc_commodity * currency) -> GNCLot *"""
    return _gnucash_core_c.xaccAccountFindLatestOpenLot(acc, sign, currency)

def xaccSplitGetCapGainsSplit(arg1: "Split const *") -> "Split *":
    r"""xaccSplitGetCapGainsSplit(Split const * arg1) -> Split *"""
    return _gnucash_core_c.xaccSplitGetCapGainsSplit(arg1)

def xaccSplitGetGainsSourceSplit(arg1: "Split const *") -> "Split *":
    r"""xaccSplitGetGainsSourceSplit(Split const * arg1) -> Split *"""
    return _gnucash_core_c.xaccSplitGetGainsSourceSplit(arg1)

def xaccSplitAssign(split: "Split *") -> "gboolean":
    r"""xaccSplitAssign(Split * split) -> gboolean"""
    return _gnucash_core_c.xaccSplitAssign(split)

def xaccSplitAssignToLot(split: "Split *", lot: "GNCLot *") -> "Split *":
    r"""xaccSplitAssignToLot(Split * split, GNCLot * lot) -> Split *"""
    return _gnucash_core_c.xaccSplitAssignToLot(split, lot)

def xaccSplitComputeCapGains(split: "Split *", gain_acc: "Account *") -> "void":
    r"""xaccSplitComputeCapGains(Split * split, Account * gain_acc)"""
    return _gnucash_core_c.xaccSplitComputeCapGains(split, gain_acc)

def xaccLotComputeCapGains(lot: "GNCLot *", gain_acc: "Account *") -> "void":
    r"""xaccLotComputeCapGains(GNCLot * lot, Account * gain_acc)"""
    return _gnucash_core_c.xaccLotComputeCapGains(lot, gain_acc)

def xaccScrubLot(lot: "GNCLot *") -> "gboolean":
    r"""xaccScrubLot(GNCLot * lot) -> gboolean"""
    return _gnucash_core_c.xaccScrubLot(lot)

def xaccAccountScrubLots(acc: "Account *") -> "void":
    r"""xaccAccountScrubLots(Account * acc)"""
    return _gnucash_core_c.xaccAccountScrubLots(acc)

def xaccAccountTreeScrubLots(acc: "Account *") -> "void":
    r"""xaccAccountTreeScrubLots(Account * acc)"""
    return _gnucash_core_c.xaccAccountTreeScrubLots(acc)


