pwncash/dhall/Types.dhall

337 lines
7.8 KiB
Plaintext
Raw Normal View History

2022-12-14 23:59:23 -05:00
let Map =
https://prelude.dhall-lang.org/v21.1.0/Map/Type
sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed
let CurID = Text
let AcntID = Text
2023-02-26 22:53:12 -05:00
let TagID = Text
2022-12-14 23:59:23 -05:00
let SqlConfig {- TODO pgsql -} = < Sqlite : Text | Postgres >
let Currency = { curSymbol : CurID, curFullname : Text }
2023-02-26 22:53:12 -05:00
let Tag = { tagID : TagID, tagDesc : Text }
2022-12-14 23:59:23 -05:00
let Gregorian = { gYear : Natural, gMonth : Natural, gDay : Natural }
let GregorianM = { gmYear : Natural, gmMonth : Natural }
let Interval = { intStart : Gregorian, intEnd : Optional Gregorian }
2022-12-14 23:59:23 -05:00
let Global = { budgetInterval : Interval, statementInterval : Interval }
let TimeUnit = < Day | Week | Month | Year >
let Weekday = < Mon | Tue | Wed | Thu | Fri | Sat | Sun >
let RepeatPat =
{ rpStart : Natural, rpBy : Natural, rpRepeats : Optional Natural }
2023-02-09 20:01:43 -05:00
let MDYPat =
< Single : Natural
| Multi : List Natural
| Repeat : RepeatPat
| After : Natural
| Before : Natural
| Between : { _between1 : Natural, _between2 : Natural }
>
2022-12-14 23:59:23 -05:00
let ModPat =
{ Type =
{ mpStart : Optional Gregorian
, mpBy : Natural
, mpUnit : TimeUnit
, mpRepeats : Optional Natural
}
, default = { mpStart = None Gregorian, mpRepeats = None Natural }
}
let WeekdayPat = < OnDay : Weekday | OnDays : List Weekday >
let CronPat =
{ Type =
{ cronWeekly : Optional WeekdayPat
, cronYear : Optional MDYPat
, cronMonth : Optional MDYPat
, cronDay : Optional MDYPat
}
, default =
{ cronWeekly = None WeekdayPat
, cronYear = None MDYPat
, cronMonth = None MDYPat
, cronDay = None MDYPat
}
}
let DatePat = < Cron : CronPat.Type | Mod : ModPat.Type >
let Decimal =
{ whole : Natural, decimal : Natural, precision : Natural, sign : Bool }
let TxOpts =
{ Type =
{ toDate : Text
, toAmount : Text
, toDesc : Text
, toOther : List Text
, toDateFmt : Text
, toAmountFmt : Text
}
, default =
{ toDate = "Date"
, toAmount = "Amount"
, toDesc = "Description"
, toOther = [] : List Text
, toDateFmt = "%0m/%0d/%Y"
, toAmountFmt = "([-+])?([0-9]+)\\.?([0-9]+)?"
}
}
let Field = \(k : Type) -> \(v : Type) -> { fKey : k, fVal : v }
let FieldMap = \(k : Type) -> \(v : Type) -> Field k (Map k v)
let MatchVal =
{ Type =
{ mvSign : Optional Bool
, mvNum : Optional Natural
, mvDen : Optional Natural
, mvPrec : Natural
}
, default =
{ mvSign = None Bool
, mvNum = None Natural
, mvDen = None Natural
, mvPrec = 2
}
}
let MatchYMD = < Y : Natural | YM : GregorianM | YMD : Gregorian >
let MatchDate = < On : MatchYMD | In : { _1 : MatchYMD, _2 : Natural } >
2022-12-24 17:54:20 -05:00
let MatchOther = < Desc : Field Text Text | Val : Field Text MatchVal.Type >
2022-12-14 23:59:23 -05:00
let SplitNum = < LookupN : Text | ConstN : Decimal | AmountN >
let SplitText =
\(t : Type) ->
< ConstT : t
| LookupT : Text
| MapT : FieldMap Text t
| Map2T : FieldMap { _1 : Text, _2 : Text } t
>
let SplitCur = SplitText CurID
let SplitAcnt = SplitText AcntID
let Split =
\(a : Type) ->
\(v : Type) ->
\(c : Type) ->
2023-02-27 22:15:03 -05:00
\(t : Type) ->
{ sAcnt : a
, sValue : v
, sCurrency : c
, sComment : Text
, sTags : List t
}
2022-12-14 23:59:23 -05:00
let ExpSplit =
2023-02-27 22:15:03 -05:00
{ Type = Split SplitAcnt (Optional SplitNum) SplitCur TagID
2022-12-14 23:59:23 -05:00
, default = { sValue = None SplitNum, sComment = "" }
}
let ToTx =
{ ttCurrency : SplitCur
, ttPath : SplitAcnt
, ttSplit : List ExpSplit.Type
}
let Match =
{ Type =
{ mDate : Optional MatchDate
, mVal : MatchVal.Type
2022-12-24 17:54:20 -05:00
, mDesc : Optional Text
2022-12-14 23:59:23 -05:00
, mOther : List MatchOther
, mTx : Optional ToTx
, mTimes : Optional Natural
, mPriority : Integer
}
, default =
{ mDate = None MatchDate
, mVal = MatchVal::{=}
2022-12-24 17:54:20 -05:00
, mDesc = None Text
2022-12-14 23:59:23 -05:00
, mOther = [] : List MatchOther
, mTx = None ToTx
, mTimes = None Natural
, mPriority = +0
}
}
let Manual =
{ manualDate : DatePat
, manualFrom : AcntID
, manualTo : AcntID
, manualValue : Decimal
, manualDesc : Text
, manualCurrency : CurID
}
let Import =
{ impPaths : List Text
, impMatches : List Match.Type
, impDelim : Natural
, impTxOpts : TxOpts.Type
, impSkipLines : Natural
}
let Statement = < StmtManual : Manual | StmtImport : Import >
let Amount = { amtValue : Decimal, amtDesc : Text }
2023-02-12 16:23:32 -05:00
let AmountType = < FixedAmt | Percent | Target >
let TimeAmount =
\(t : Type) -> { taWhen : t, taAmt : Amount, taAmtType : AmountType }
2022-12-14 23:59:23 -05:00
let DateAmount = TimeAmount DatePat
2022-12-14 23:59:23 -05:00
2023-02-26 12:03:35 -05:00
let Exchange =
{ xFromCur : CurID, xToCur : CurID, xAcnt : AcntID, xRate : Decimal }
let BudgetCurrency = < NoX : CurID | X : Exchange >
2023-02-26 22:53:12 -05:00
let TaggedAcnt = { taAcnt : AcntID, taTags : List TagID }
let Allocation_ =
\(t : Type) ->
{ alloTo : TaggedAcnt, alloAmts : List t, alloCur : BudgetCurrency }
let Allocation = Allocation_ Amount
let IntervalAllocation = Allocation_ (TimeAmount Interval)
2023-01-29 18:04:24 -05:00
2022-12-14 23:59:23 -05:00
let Income =
2023-03-16 23:55:59 -04:00
{ Type =
{ incGross : Decimal
, incCurrency : CurID
, incWhen : DatePat
, incPretax : List Allocation
, incTaxes : List Allocation
, incPosttax : List Allocation
, incFrom :
{- this must be an income AcntID, and is the only place income
accounts may be specified in the entire budget -}
TaggedAcnt
, incToBal : TaggedAcnt
}
, default =
{ incPretax = [] : List Allocation
, incTaxes = [] : List Allocation
, incPosttaxx = [] : List Allocation
}
2022-12-14 23:59:23 -05:00
}
2023-01-30 21:12:08 -05:00
let Transfer =
2023-02-26 22:53:12 -05:00
{ transFrom : TaggedAcnt
, transTo : TaggedAcnt
, transAmounts : List DateAmount
2023-02-26 12:03:35 -05:00
, transCurrency : BudgetCurrency
2022-12-14 23:59:23 -05:00
}
let AcntSet =
{ Type = { asList : List AcntID, asInclude : Bool }
, default = { asList = [] : List AcntID, asInclude = False }
}
2023-02-13 19:57:39 -05:00
let ShadowMatch =
{ Type =
{ smFrom : AcntSet.Type
, smTo : AcntSet.Type
2023-02-13 19:57:39 -05:00
, smDate : Optional MatchDate
, smVal : MatchVal.Type
}
, default =
{ smFrom = AcntSet.default
, smTo = AcntSet.default
2023-02-13 19:57:39 -05:00
, smDate = None MatchDate
, smVal = MatchVal.default
}
}
let ShadowTransfer =
2023-02-26 22:53:12 -05:00
{ stFrom : TaggedAcnt
, stTo : TaggedAcnt
2023-02-13 19:57:39 -05:00
, stCurrency : CurID
, stDesc : Text
, stMatch : ShadowMatch.Type
, stRatio : Decimal
}
2023-02-05 18:45:56 -05:00
let Budget =
2023-02-13 19:57:39 -05:00
{ budgetLabel : Text
2023-03-16 23:55:59 -04:00
, incomes : List Income.Type
, pretax : List IntervalAllocation
, tax : List IntervalAllocation
, posttax : List IntervalAllocation
2023-02-13 19:57:39 -05:00
, transfers : List Transfer
, shadowTransfers : List ShadowTransfer
}
2022-12-14 23:59:23 -05:00
in { CurID
, AcntID
, SqlConfig
, Currency
2023-02-26 22:53:12 -05:00
, Tag
2023-02-27 21:57:35 -05:00
, TagID
2022-12-14 23:59:23 -05:00
, Interval
, Global
, Gregorian
, GregorianM
, TimeUnit
, Weekday
, RepeatPat
, MDYPat
, ModPat
, WeekdayPat
, CronPat
, DatePat
, Decimal
, TxOpts
, Match
, MatchVal
, MatchYMD
, MatchDate
, MatchOther
, SplitNum
, Field
, FieldMap
, Split
, ExpSplit
, SplitText
, SplitCur
, SplitAcnt
, ToTx
, Import
, Manual
, Statement
2023-01-30 21:12:08 -05:00
, Transfer
2022-12-15 22:55:12 -05:00
, Income
2022-12-14 23:59:23 -05:00
, Budget
2023-01-29 18:04:24 -05:00
, Allocation
, IntervalAllocation
2023-01-29 18:14:00 -05:00
, Amount
, TimeAmount
2023-02-12 16:23:32 -05:00
, AmountType
2023-02-13 19:57:39 -05:00
, ShadowMatch
, ShadowTransfer
, AcntSet
2023-02-26 12:03:35 -05:00
, BudgetCurrency
, Exchange
2023-02-26 22:53:12 -05:00
, TaggedAcnt
2022-12-14 23:59:23 -05:00
}