h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                           Safe-Inferredhaspara'Common Aeson encoding/decoding options.hasparaAeson encoding/decoding options for uppercase constructor tag modifiers Safe-Inferred"1;>haspara!Type encoding of a currency pair.1 values are constructed via the data constructor::set -XOverloadedStringsCurrencyPair "EUR" "USD"EUR/USD and  instances are provided as well:Aeson.decode "{\"base\": \"EUR\", \"quote\": \"EUR\"}" :: Maybe CurrencyPair Just EUR/EUR'Aeson.encode (CurrencyPair "EUR" "USD")&"{\"base\":\"EUR\",\"quote\":\"USD\"}"haspara Base currency+ of the currency pair. Also referred to as counter currency.hasparaQuote currency+ of the currency pair. Also referred to as transaction currency.haspara:Type encoding for currency symbol values with a syntax of [A-Z]{3}[A-Z]*. values can be constructed via   that works in   context::set -XOverloadedStrings/mkCurrencyError "EUR" :: Either T.Text Currency Right EUR ... or via   that works in  context:&mkCurrencyFail "EUR" :: Maybe CurrencyJust EURAn = instance is provided as well which is unsafe but convenient:"EUR" :: CurrencyEUR hasparaSmart constructor for  values within  context.:set -XOverloadedStrings,mkCurrencyError "" :: Either T.Text CurrencyLeft "Currency code error! Expecting at least 3 uppercase ASCII letters, but received: "-mkCurrencyError " " :: Either T.Text CurrencyLeft "Currency code error! Expecting at least 3 uppercase ASCII letters, but received: ".mkCurrencyError "AB" :: Either T.Text CurrencyLeft "Currency code error! Expecting at least 3 uppercase ASCII letters, but received: AB"1mkCurrencyError " ABC " :: Either T.Text CurrencyLeft "Currency code error! Expecting at least 3 uppercase ASCII letters, but received: ABC "/mkCurrencyError "ABC" :: Either T.Text Currency Right ABC hasparaSmart constructor for  values within  context.:set -XOverloadedStrings#mkCurrencyFail "" :: Maybe CurrencyNothing%mkCurrencyFail "US" :: Maybe CurrencyNothing&mkCurrencyFail "usd" :: Maybe CurrencyNothing&mkCurrencyFail "USD" :: Maybe CurrencyJust USD haspara"Parser that parses currency codes. :set -XOverloadedStrings,MP.runParser currencyCodeParser "Example" ""Left (ParseErrorBundle {bundleErrors = TrivialError 0 (Just EndOfInput) (fromList []) :| [], bundlePosState = PosState {pstateInput = "", pstateOffset = 0, pstateSourcePos = SourcePos {sourceName = "Example", sourceLine = Pos 1, sourceColumn = Pos 1}, pstateTabWidth = Pos 8, pstateLinePrefix = ""}})-MP.runParser currencyCodeParser "Example" " "Left (ParseErrorBundle {bundleErrors = TrivialError 0 (Just (Tokens (' ' :| ""))) (fromList []) :| [], bundlePosState = PosState {pstateInput = " ", pstateOffset = 0, pstateSourcePos = SourcePos {sourceName = "Example", sourceLine = Pos 1, sourceColumn = Pos 1}, pstateTabWidth = Pos 8, pstateLinePrefix = ""}})-MP.runParser currencyCodeParser "Example" "a"Left (ParseErrorBundle {bundleErrors = TrivialError 0 (Just (Tokens ('a' :| ""))) (fromList []) :| [], bundlePosState = PosState {pstateInput = "a", pstateOffset = 0, pstateSourcePos = SourcePos {sourceName = "Example", sourceLine = Pos 1, sourceColumn = Pos 1}, pstateTabWidth = Pos 8, pstateLinePrefix = ""}})-MP.runParser currencyCodeParser "Example" "A"Left (ParseErrorBundle {bundleErrors = TrivialError 1 (Just EndOfInput) (fromList []) :| [], bundlePosState = PosState {pstateInput = "A", pstateOffset = 0, pstateSourcePos = SourcePos {sourceName = "Example", sourceLine = Pos 1, sourceColumn = Pos 1}, pstateTabWidth = Pos 8, pstateLinePrefix = ""}}).MP.runParser currencyCodeParser "Example" "AB"Left (ParseErrorBundle {bundleErrors = TrivialError 2 (Just EndOfInput) (fromList []) :| [], bundlePosState = PosState {pstateInput = "AB", pstateOffset = 0, pstateSourcePos = SourcePos {sourceName = "Example", sourceLine = Pos 1, sourceColumn = Pos 1}, pstateTabWidth = Pos 8, pstateLinePrefix = ""}})/MP.runParser currencyCodeParser "Example" "ABC" Right "ABC"0MP.runParser currencyCodeParser "Example" "ABCD" Right "ABCD"2MP.runParser currencyCodeParser "Example" " ABCD "Left (ParseErrorBundle {bundleErrors = TrivialError 0 (Just (Tokens (' ' :| ""))) (fromList []) :| [], bundlePosState = PosState {pstateInput = " ABCD ", pstateOffset = 0, pstateSourcePos = SourcePos {sourceName = "Example", sourceLine = Pos 1, sourceColumn = Pos 1}, pstateTabWidth = Pos 8, pstateLinePrefix = ""}}) haspara Converts a  to a 2-tuple of  values.:set -XOverloadedStrings*toCurrencyTuple (CurrencyPair "EUR" "USD") (EUR,USD) hasparaConverts a 2-tuple of  values to a .:set -XOverloadedStrings fromCurrencyTuple ("EUR", "USD")EUR/USDhaspara instance for .:set -XOverloadedStrings Aeson.encode ("USD" :: Currency) "\"USD\""haspara instance for .:set -XOverloadedStrings3Aeson.eitherDecode "\"\"" :: Either String CurrencyLeft "Error in $: Currency code error! Expecting at least 3 uppercase ASCII letters, but received: "4Aeson.eitherDecode "\"A\"" :: Either String CurrencyLeft "Error in $: Currency code error! Expecting at least 3 uppercase ASCII letters, but received: A"5Aeson.eitherDecode "\"AB\"" :: Either String CurrencyLeft "Error in $: Currency code error! Expecting at least 3 uppercase ASCII letters, but received: AB"6Aeson.eitherDecode "\"ABC\"" :: Either String Currency Right ABC7Aeson.eitherDecode "\"ABCD\"" :: Either String Currency Right ABCDhaspara instance for .:set -XOverloadedStrings"USD" :: CurrencyUSDhaspara instance for .:set -XOverloadedStrings"USD" :: CurrencyUSDhaspara instance for .:set -XOverloadedStringsCurrencyPair "EUR" "USD"EUR/USD     Safe-Inferred"1;%haspara!Type encoding for account values."This definition provides both the ! and an arbitrary object identifying the account. This arbitrary nature provides flexibility to use-site to use its own account identity and accompanying information when required.:set -XTypeApplications,let acc = Account AccountKindAsset (1 ::Int)Data.Aeson.encode acc#"{\"kind\":\"ASSET\",\"object\":1}"8Data.Aeson.decode @(Account Int) (Data.Aeson.encode acc)Just (Account {accountKind = AccountKindAsset, accountObject = 1})5Data.Aeson.decode (Data.Aeson.encode acc) == Just accTrue!haspara&Type encoding for ledger account type.This type covers both balance sheet and income statement account types: For balance sheet accounts:Asset (") Liability (#)Equity ($)For income statement accounts: Revenue (%) Expense (&) and  instances, too: :set -XTypeApplications*Data.Aeson.decode @AccountKind "\"ASSET\""Just AccountKindAsset.Data.Aeson.decode @AccountKind "\"LIABILITY\""Just AccountKindLiability+Data.Aeson.decode @AccountKind "\"EQUITY\""Just AccountKindEquity,Data.Aeson.decode @AccountKind "\"REVENUE\""Just AccountKindRevenue,Data.Aeson.decode @AccountKind "\"EXPENSE\""Just AccountKindExpense"Data.Aeson.encode AccountKindAsset "\"ASSET\""&Data.Aeson.encode AccountKindLiability"\"LIABILITY\""#Data.Aeson.encode AccountKindEquity "\"EQUITY\""$Data.Aeson.encode AccountKindRevenue "\"REVENUE\""$Data.Aeson.encode AccountKindExpense "\"EXPENSE\""'haspara+Provides textual representation of a given !. accountKindText AccountKindAsset"Asset"$accountKindText AccountKindLiability "Liability"!accountKindText AccountKindEquity"Equity""accountKindText AccountKindRevenue "Revenue""accountKindText AccountKindExpense "Expense"  !&%$#"' !&%$#"'  Safe-Inferred15;>J{8hasparaType definition for unsigned 9 values.9hasparaType encoding for quantity values with a given scaling (digits after the decimal point).42 :: Quantity 04242 :: Quantity 142.042 :: Quantity 242.0041 + 1 :: Quantity 242.0043 - 1 :: Quantity 242.002 * 3 * 7 :: Quantity 242.00negate (-42) :: Quantity 242.00abs (-42) :: Quantity 242.00signum (-42) :: Quantity 2-1.00fromInteger 42 :: Quantity 242.00mkQuantity 0.415 :: Quantity 20.42mkQuantity 0.425 :: Quantity 20.425mkQuantityLossless 0.42 :: Either String (Quantity 2) Right 0.426mkQuantityLossless 0.415 :: Either String (Quantity 2)7Left "Underflow while trying to create quantity: 0.415"<haspara Constructs 9 values from  values in a lossy way.This function uses G> in case that the lossless attempt fails. We could have used G directly. However, G is doing too much (see H). Therefore, we are first attempting a lossless construction (see =) and we fallback to G) in case the lossless construction fails.mkQuantity 0 :: Quantity 00mkQuantity 0 :: Quantity 10.0mkQuantity 0 :: Quantity 20.00mkQuantity 0.04 :: Quantity 10.0mkQuantity 0.05 :: Quantity 10.0mkQuantity 0.06 :: Quantity 10.1mkQuantity 0.14 :: Quantity 10.1mkQuantity 0.15 :: Quantity 10.2mkQuantity 0.16 :: Quantity 10.2mkQuantity 0.04 :: Quantity 20.04mkQuantity 0.05 :: Quantity 20.05mkQuantity 0.06 :: Quantity 20.06mkQuantity 0.14 :: Quantity 20.14mkQuantity 0.15 :: Quantity 20.15mkQuantity 0.16 :: Quantity 20.16mkQuantity 0.04 :: Quantity 30.040mkQuantity 0.05 :: Quantity 30.050mkQuantity 0.06 :: Quantity 30.060mkQuantity 0.14 :: Quantity 30.140mkQuantity 0.15 :: Quantity 30.150mkQuantity 0.16 :: Quantity 30.160=haspara Constructs 9 values from  values in a lossy way.2mkQuantityLossless 0 :: Either String (Quantity 0)Right 02mkQuantityLossless 0 :: Either String (Quantity 1) Right 0.02mkQuantityLossless 0 :: Either String (Quantity 2) Right 0.005mkQuantityLossless 0.04 :: Either String (Quantity 1)8Left "Underflow while trying to create quantity: 4.0e-2"5mkQuantityLossless 0.05 :: Either String (Quantity 1)8Left "Underflow while trying to create quantity: 5.0e-2"5mkQuantityLossless 0.06 :: Either String (Quantity 1)8Left "Underflow while trying to create quantity: 6.0e-2"5mkQuantityLossless 0.14 :: Either String (Quantity 1)6Left "Underflow while trying to create quantity: 0.14"5mkQuantityLossless 0.15 :: Either String (Quantity 1)6Left "Underflow while trying to create quantity: 0.15"5mkQuantityLossless 0.16 :: Either String (Quantity 1)6Left "Underflow while trying to create quantity: 0.16"5mkQuantityLossless 0.04 :: Either String (Quantity 2) Right 0.045mkQuantityLossless 0.05 :: Either String (Quantity 2) Right 0.055mkQuantityLossless 0.06 :: Either String (Quantity 2) Right 0.065mkQuantityLossless 0.14 :: Either String (Quantity 2) Right 0.145mkQuantityLossless 0.15 :: Either String (Quantity 2) Right 0.155mkQuantityLossless 0.16 :: Either String (Quantity 2) Right 0.165mkQuantityLossless 0.04 :: Either String (Quantity 3) Right 0.0405mkQuantityLossless 0.05 :: Either String (Quantity 3) Right 0.0505mkQuantityLossless 0.06 :: Either String (Quantity 3) Right 0.0605mkQuantityLossless 0.14 :: Either String (Quantity 3) Right 0.1405mkQuantityLossless 0.15 :: Either String (Quantity 3) Right 0.1505mkQuantityLossless 0.16 :: Either String (Quantity 3) Right 0.160>hasparaRounds given quantity by k digits.?@ABCDEFGH9;:8<=>?@ABCDEFGH Safe-Inferred"1;] Thaspara3Type encoding for FX rate quotation database for a .ZhasparaType encoding for a dictionary-based FX rate quotation database for various  values.[haspara:Type encoding for FX rate quotations with fixed precision.%An FX rate quotation is a 3-tuple of: +a currency pair the rate is quoted for, and-a date that the quotation is effective as of,0a (positive) rate as the value of the quotation.]hasparaCurrency pair of the FX rate.^hasparaActual date of the FX rate._haspara%(Positive) rate value of the FX rate.`hasparaSmart constructor for [ values within   context.The rate is expected to be a positive value. If it is not, the function will throw an error.:set -XTypeApplicationsmkFxQuoteError @(Either _) @2 "EUR" "USD" (read "2021-12-31") 1.16Right (MkFxQuote {fxQuotePair = EUR/USD, fxQuoteDate = 2021-12-31, fxQuoteRate = Refined 1.16})mkFxQuoteError @(Either _) @2 "EUR" "USD" (read "2021-12-31") (-1.16)Left "Can not create FX Rate. Error was: The predicate (GreaterThan 0) failed with the message: Value is not greater than 0\n"ahasparaSmart constructor for [ values within  context.The rate is expected to be a positive value. If it is not, the function will fail.:set -XTypeApplications v == valueFromAmount k (amountFromValue k v)..., and for the list of !s.3let kinds = [minBound .. maxBound] :: [AccountKind]kinds[AccountKindAsset,AccountKindLiability,AccountKindEquity,AccountKindRevenue,AccountKindExpense]All checks should pass:2all (\k -> check k valPos && check k valNeg) kindsTruehaspara Builds the / value for the given account kind and quantity.The concept of quantity here refers to the conventional concept of what it means for an  of a given !.For example, a loan of USD 1,000 has an increase in our liabilities. Therefore, the quantity is expected to be positive::set -XDataKindsimport Haspara.QuantityamountFromQuantity AccountKindLiability (mkQuantity 1000 :: Quantity 2)?Amount {amountSide = SideCredit, amountValue = Refined 1000.00}Note  function if you are rather working with values that are conceptually different than the quantity here whereby a value refers to the value of a particular economic event as in the contribution of that event to the net-worth of the entity. Therefore, above example would be reflected as follows to get the same  value:amountFromValue AccountKindLiability (mkQuantity (-1000) :: Quantity 2)?Amount {amountSide = SideCredit, amountValue = Refined 1000.00}Check ' documentation for further information.haspara*Returns the quantity for the given amount.This is dual to .haspara instance for .:set -XDataKindsimport Haspara.Accounting.Sideimport Haspara.Quantityimport Refined.UnsafeAeson.encode (Amount SideDebit (unsafeRefine (mkQuantity 42 :: Quantity 2)))""{\"side\":\"db\",\"value\":42.0}"Aeson.encode (Amount SideCredit (unsafeRefine (mkQuantity 42 :: Quantity 2)))""{\"side\":\"cr\",\"value\":42.0}"Aeson.eitherDecode (Aeson.encode (Amount SideDebit (unsafeRefine (mkQuantity 42 :: Quantity 2)))) :: Either String (Amount 2)Right (Amount {amountSide = SideDebit, amountValue = Refined 42.00})Aeson.eitherDecode (Aeson.encode (Amount SideCredit (unsafeRefine (mkQuantity 42 :: Quantity 2)))) :: Either String (Amount 2)Right (Amount {amountSide = SideCredit, amountValue = Refined 42.00})haspara instance for .:set -XDataKinds:set -XOverloadedStringsAeson.eitherDecode "{\"side\": \"db\", \"value\": 42}" :: Either String (Amount 2)Right (Amount {amountSide = SideDebit, amountValue = Refined 42.00})Aeson.eitherDecode "{\"side\": \"cr\", \"value\": 42}" :: Either String (Amount 2)Right (Amount {amountSide = SideCredit, amountValue = Refined 42.00})    Safe-Inferred1; haspara$Data definition for inventory event.haspara)Data definition for a journal entry item.A journal entry item has a , an unsigned quantity as amount, an account that it belongs to and the event the item is originating from. Journal entry item definition is polymorphic over the precision of the monetary quantities, the account and event objects.haspara$Data definition for a journal entry.A journal entry has a (unique) identifier, date and description, and a list of s. Journal entry definition is polymorphic over the precision of the monetary quantities, the account and event objects.hasparaData definition for the journal entries of interest (like a general ledger.)A  is a list of  records which are polymorphic over the precision of the monetary quantities, the account and event objects.haspara2Returns the total debit amount of a journal entry.haspara3Returns the total credit amount of a journal entry.haspara9Predicate to check if a journal entry is balanced or not.The logical check is indeed whether the total debit amount is equal to the total credit amount or not.haspara Creates a  from the given signed value, the account it belongs to and the event it is originating from.The value is defined as in  function.haspara Creates a 8 with inventory event informationfrom the given signed value, the account it belongs to and the event it is originating from.The value is defined as in  function.  Safe-Inferred1;> hasparaData definition for balances.This definition is similar to , however, the value is allowed to be negative to reflect "Negative Balance" phenomenon.See https://www.accountingtools.com/articles/what-is-a-negative-balance.htmlhaspara#Returns the debit quantity, if any.haspara$Returns the credit quantity, if any.haspara*Updates the balance with the given amount. :set -XDataKindsimport Data.Default (def) import Haspara.Accounting.Amountimport Haspara.Accounting.Sideimport Refined.Unsafe3let balance = Balance SideDebit 42 def :: Balance 2balanceBalance {balanceSide = SideDebit, balanceValue = 42.00, balanceInventory = MkInventory {inventoryTotal = 0.000000000000, inventoryCurrent = fromList [], inventoryHistory = fromList []}}let amountDebit = Amount SideDebit (unsafeRefine 10) :: Amount 2 amountDebit?@ABCDEFGHTYXWUVZ[_^\]`abcdefghiqtrsuvwx|{yz} Safe-Inferredhaspara Constructs a 9 value at compile-time using -XTemplateHaskell.:set -XDataKinds:set -XOverloadedStrings:set -XTemplateHaskell!$$(quantityTH 0.00) :: Quantity 20.00!$$(quantityTH 0.09) :: Quantity 20.09"$$(quantityTH 0.009) :: Quantity 2...6..."Underflow while trying to create quantity: 9.0e-3"..."$$(quantityTH 0.009) :: Quantity 30.009haspara Constructs a  value at compile-time using -XTemplateHaskell.:set -XOverloadedStrings:set -XTemplateHaskell$$(currencyTH "USD")USD$$(currencyTH "usd")......Currency code error! Expecting at least 3 uppercase ASCII letters, but received: usd...haspara Constructs a  value at compile-time using -XTemplateHaskell.:set -XOverloadedStrings:set -XTemplateHaskell$$(currencyPairTH "EUR" "USD")EUR/USD$$(currencyPairTH "USD" "USD")USD/USD$$(currencyPairTH "USD" "eur")...... Currency code error! Expecting at least 3 uppercase ASCII letters, but received: eur... Safe-Inferred !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhijklmnopqrstuvwxyz{|}~                                                                                                                                          &haspara-0.0.0.8-83lIPqySeX32MZXT98KoZ2Haspara.Internal.AesonHaspara.CurrencyHaspara.Accounting.AccountHaspara.QuantityHaspara.FxQuoteHaspara.MonetaryHaspara.Accounting.SideHaspara.Accounting.InventoryHaspara.Accounting.AmountHaspara.Accounting.JournalHaspara.Accounting.BalanceHaspara.Accounting.LedgerHaspara.Accounting.TrialBalance Haspara.TH Data.AesonFromJSONToJSONHasparaMonetaryAccountHaspara.Accounting Paths_hasparacommonAesonOptionsaesonOptionsForSingleTag CurrencyPaircurrencyPairBasecurrencyPairQuoteCurrency MkCurrency currencyCodemkCurrencyErrormkCurrencyFailcurrencyCodeParsertoCurrencyTuplefromCurrencyTuple$fToJSONCurrency$fFromJSONCurrency$fShowCurrency$fIsStringCurrency$fShowCurrencyPair$fToJSONCurrencyPair$fFromJSONCurrencyPair$fEqCurrencyPair$fGenericCurrencyPair$fOrdCurrencyPair$fLiftBoxedRepCurrencyPair $fEqCurrency$fHashableCurrency $fOrdCurrency$fLiftBoxedRepCurrency accountKind accountObject AccountKindAccountKindAssetAccountKindLiabilityAccountKindEquityAccountKindRevenueAccountKindExpenseaccountKindText$fToJSONAccountKind$fFromJSONAccountKind$fHashableAccountKind$fToJSONAccount$fFromJSONAccount$fHashableAccount $fEqAccount$fGenericAccount $fOrdAccount $fShowAccount$fBoundedAccountKind$fEnumAccountKind$fEqAccountKind$fGenericAccountKind$fOrdAccountKind$fShowAccountKindUnsignedQuantityQuantity MkQuantity unQuantity mkQuantitymkQuantityLossless roundQuantitytimes timesLosslessdividedivideLdivideRdivideDsumUnsignedQuantity absQuantity mkQuantityAuxroundScientific$fShowQuantity$fFractionalArith $fNumArith$fToJSONQuantity$fFromJSONQuantity $fEqQuantity $fOrdQuantity$fGenericQuantity $fNumQuantity$fLiftBoxedRepQuantity$fLiftBoxedRepDecimalFxQuotePairDatabasefxQuotePairDatabasePairfxQuotePairDatabaseTablefxQuotePairDatabaseSincefxQuotePairDatabaseUntilFxQuoteDatabaseFxQuote MkFxQuote fxQuotePair fxQuoteDate fxQuoteRatemkFxQuoteError mkFxQuoteFailmkFxQuoteUnsafe findFxQuotefindFxQuoteAuxemptyFxQuoteDatabase addFxQuotes addFxQuoteinitFxQuotePairDatabaseupdateFxQuotePairDatabase$fToJSONFxQuote$fFromJSONFxQuote$fShowFxQuotePairDatabase $fEqFxQuote$fGenericFxQuote $fOrdFxQuote $fShowFxQuoteMonetaryExceptionIncompatibleCurrenciesExceptionIncompatibleDatesExceptionInconsistentFxQuoteExceptionconvertM convertAsofMMoney moneyDate moneyCurrency moneyQuantityconvert $fToJSONMoney$fFromJSONMoney$fExceptionMonetaryException $fEqMoney$fGenericMoney $fOrdMoney $fShowMoney$fShowMonetaryExceptionSide SideDebit SideCredit otherSidesideByAccountKindnormalSideByAccountKind $fToJSONSide$fFromJSONSide$fEqSide $fOrdSide $fShowSideMunchMunchNoMunchAll MunchLeft MunchRightInventoryHistoryItemMkInventoryHistoryIteminventoryHistoryItemDateinventoryHistoryItemPnlinventoryHistoryItemFstinventoryHistoryItemSndInventoryEventinventoryEventDateinventoryEventPriceinventoryEventQuantity Inventory MkInventoryinventoryTotalinventoryCurrentinventoryHistoryupdateInventoryupdateInventoryVPupdateInventoryVVupdateInventoryAux splitEventaddInventoryEventmunchAll whatMunch$fToJSONInventoryEvent$fFromJSONInventoryEvent$fToJSONInventoryHistoryItem$fFromJSONInventoryHistoryItem$fToJSONInventory$fFromJSONInventory$fDefaultInventory $fEqMunch $fShowMunch $fEqInventory$fGenericInventory$fShowInventory$fEqInventoryHistoryItem$fGenericInventoryHistoryItem$fShowInventoryHistoryItem$fEqInventoryEvent$fGenericInventoryEvent$fShowInventoryEventAmount amountSide amountValue amountDebit amountCreditamountFromValuevalueFromAmountamountFromQuantityquantityFromAmount$fToJSONAmount$fFromJSONAmount $fEqAmount$fGenericAmount $fOrdAmount $fShowAmountJournalEntryItemInventoryEvent(journalEntryItemInventoryEventPnlAccount#journalEntryItemInventoryEventEvent&journalEntryItemInventoryEventQuantityJournalEntryItemjournalEntryItemAmountjournalEntryItemAccountjournalEntryItemEventjournalEntryItemInventoryEvent JournalEntryjournalEntryIdjournalEntryDatejournalEntryItemsjournalEntryDescriptionJournaljournalEntriesjournalEntryTotalDebitjournalEntryTotalCreditisJournalEntryBalancedmkJournalEntryItemFromValue$mkInventoryJournalEntryItemFromValue&$fToJSONJournalEntryItemInventoryEvent($fFromJSONJournalEntryItemInventoryEvent$fToJSONJournalEntryItem$fFromJSONJournalEntryItem$fToJSONJournalEntry$fFromJSONJournalEntry$fToJSONJournal$fFromJSONJournal$fGenericJournal $fShowJournal$fGenericJournalEntry$fShowJournalEntry$fEqJournalEntryItem$fGenericJournalEntryItem$fShowJournalEntryItem"$fEqJournalEntryItemInventoryEvent'$fGenericJournalEntryItemInventoryEvent$$fShowJournalEntryItemInventoryEventBalance balanceSide balanceValuebalanceInventory balanceDebit balanceCredit updateBalanceupdateBalanceWithInventoryamountFromBalancequantityFromBalancevalueFromBalance$fToJSONBalance$fFromJSONBalance $fEqBalance$fGenericBalance $fShowBalance LedgerEntryledgerEntryDateledgerEntryAmountledgerEntryDescriptionledgerEntryEventledgerEntryPostingIdledgerEntryBalanceLedger ledgerAccount ledgerOpening ledgerRunning GeneralLedgergeneralLedgerLedgers ledgerClosing initLedgerinitLedgerWithOpeningBalanceinitLedgerWithOpeningValueinitLedgerWithOpeningQuantity postEntries postEntry postEntryItempostItemhistItemToJournalEntryItem$fToJSONLedgerEntry$fFromJSONLedgerEntry$fToJSONLedger$fFromJSONLedger$fToJSONGeneralLedger$fFromJSONGeneralLedger$fEqGeneralLedger$fGenericGeneralLedger$fShowGeneralLedger $fEqLedger$fGenericLedger $fShowLedger$fEqLedgerEntry$fGenericLedgerEntry$fShowLedgerEntryTrialBalanceItemtrialBalanceItemLedgertrialBalanceItemBalance TrialBalancetrialBalanceItemstrialBalanceItemAmountprepareTrialBalancemkTrialBalanceItemtrialBalanceTotals$fToJSONTrialBalanceItem$fFromJSONTrialBalanceItem$fToJSONTrialBalance$fFromJSONTrialBalance$fEqTrialBalance$fGenericTrialBalance$fShowTrialBalance$fEqTrialBalanceItem$fGenericTrialBalanceItem$fShowTrialBalanceItem quantityTH currencyTHcurrencyPairTH$aeson-2.0.3.0-GSlxW2j9OEgDymS5ekqvUNData.Aeson.Types.FromJSONData.Aeson.Types.ToJSON mtl-2.2.2Control.Monad.Error.Class MonadError text-1.2.5.0Data.Text.InternalTextbaseControl.Monad.Fail MonadFail Data.StringIsStringGHC.ShowShow)scientific-0.3.7.0-1TWVLTnDh4ADU7EwmydYIKData.Scientific Scientifictemplate-haskellLanguage.Haskell.TH.SyntaxLiftGHC.Errerror time-1.11.1.1Data.Time.Calendar.DaysDay1data-default-class-0.1.2.0-CQYBH38PFES4dDyailJWvdData.Default.ClassdefversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir