@pax2pay/model-banking 0.1.613 → 0.1.615

package/Amount.ts

@@ -1,7 +1,5 @@
 import { isoly } from "isoly"
-import { isoly as isoly2 } from "isoly2"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Amounts } from "./Amounts"
 
 export type Amount = [isoly.Currency, number]
@@ -11,8 +9,4 @@ export namespace Amount {
 		return !amount ? {} : Object.fromEntries<number>([amount])
 	}
 	export const type = isly.tuple<Amount>(isly.string(isoly.Currency.values), isly.number())
-	export const type2 = isly2.tuple<Amount>(
-		isoly2.Currency.type,
-		isly2.number().rename("Amount").describe("Amount in a specified currency.")
-	)
 }

package/Card/Changeable.ts

@@ -1,7 +1,5 @@
 import { isoly } from "isoly"
-import { isoly as isoly2 } from "isoly2"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Amount } from "../Amount"
 import { Meta } from "./Meta"
 
@@ -15,15 +13,4 @@ export namespace Changeable {
 		limit: isly.tuple(isly.fromIs("isoly.Currency", isoly.Currency.is), isly.number()).optional(),
 		meta: isly.fromIs("Card.Meta", Meta.is).optional(),
 	})
-	export const type2: isly2.Object<Changeable> = isly2
-		.object<Changeable>({
-			limit: isly2
-				.tuple(isoly2.Currency.type, isly2.number())
-				.optional()
-				.rename("Limit")
-				.describe("The new limit of the card."),
-			meta: isly2.from("Card.Meta", Meta.is).optional().rename("Meta").describe("The new meta data of the card."),
-		})
-		.rename("Changeable")
-		.describe("Changeable card properties.")
 }

package/Card/Creatable.ts

@@ -1,7 +1,5 @@
 import { isoly } from "isoly"
-import { isoly as isoly2 } from "isoly2"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Amount } from "../Amount"
 import type { Rule } from "../Rule"
 import { type as ruleType } from "../Rule/type"
@@ -37,30 +35,4 @@ export namespace Creatable {
 		key: isly.string().optional(),
 		restricted: isly.object<Required<Creatable>["restricted"]>({ to: Restriction.type.optional() }).optional(),
 	})
-	export const type2 = isly2.object<Creatable>({
-		account: isly2.string().rename("Account").describe("The account id the card was created on."),
-		number: isly2.string().optional().rename("Number").describe("The card identifier of the user of the api."),
-		preset: Preset.type2,
-		details: isly2
-			.object({ expiry: Expiry.type2, holder: isly2.string() })
-			.rename("Details")
-			.describe("The card details, the information that will be displayed on the card."),
-		limit: isly2
-			.tuple(isoly2.Currency.type, isly2.number().rename("Amount").describe("Amount in a specified currency."))
-			.rename("Limit")
-			.describe("Maximum amount that can be spent on the card."),
-		rules: isly2
-			.from("Rule", ruleType.is)
-			.array()
-			.optional()
-			.rename("Rules")
-			.describe("Card rules that applies to authorizations made with the card."),
-		meta: isly2.from("Meta", Meta.is).optional(),
-		key: isly2.string().optional(),
-		restricted: isly2
-			.object<Required<Creatable>["restricted"]>({ to: Restriction.type2.optional() })
-			.optional()
-			.rename("Restrictions")
-			.describe("Set of restrictions that apply to the card."),
-	})
 }

package/Card/Expiry.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 
 const year = [23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40] as const
 type Year = (typeof year)[number]
@@ -11,19 +10,6 @@ type Month = (typeof month)[number]
 export type Expiry = [Year, Month]
 export namespace Expiry {
 	export const type = isly.tuple<Expiry>(isly.number([...year]), isly.number([...month])) // Deconstructing to remove readonly.
-	export const type2: isly2.Tuple<Expiry> = isly2
-		.tuple<Expiry>(
-			isly2
-				.number("value", ...year)
-				.rename("Year")
-				.describe("Year of expiry."),
-			isly2
-				.number("value", ...month)
-				.rename("Month")
-				.describe("Month of expiry.")
-		)
-		.rename("Expiry")
-		.describe("The year and month the card is valid ([yy, mm]).")
 	export function toDateTime(expiry: Expiry): isoly.DateTime {
 		return isoly.DateTime.nextMonth(
 			"20" + expiry[0].toString() + "-" + expiry[1].toString().padStart(2, "0") + "-01T00:00:01.000Z"

package/Card/Operation/Authorization.ts

@@ -1,7 +1,6 @@
 import { isoly } from "isoly"
-import { isoly as isoly2 } from "isoly2"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
+
 export interface Authorization {
 	type: "authorization"
 	id: string
@@ -9,7 +8,6 @@ export interface Authorization {
 	reason?: string
 	created: isoly.DateTime
 }
-
 export namespace Authorization {
 	export const statuses = ["created", "confirmed", "refunded", "captured", "cancelled"] as const
 	export type Status = (typeof statuses)[number]
@@ -20,14 +18,4 @@ export namespace Authorization {
 		reason: isly.string().optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})
-	export const type2 = isly2.object<Authorization>({
-		type: isly2.string("value", "authorization").rename("Operation.Type").describe("Type of operation."),
-		id: isly2.string().rename("Id").describe("The id of the operation."),
-		status: isly2
-			.string("value", ...statuses)
-			.rename("Status")
-			.describe("The updated status of the operation."),
-		reason: isly2.string().optional().rename("Reason").describe("The reason for the status change."),
-		created: isoly2.DateTime.type.describe("The time of the operation."),
-	})
 }

package/Card/Operation/Card.ts

@@ -1,7 +1,5 @@
 import { isoly } from "isoly"
-import { isoly as isoly2 } from "isoly2"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Changeable } from "../Changeable"
 
 export interface Card {
@@ -20,16 +18,4 @@ export namespace Card {
 		from: Changeable.type.optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})
-	export const type2: isly2.Object<Card> = isly2
-		.object<Card>({
-			type: isly2.string("value", "card").rename("Type").describe("Type of operation."),
-			status: isly2
-				.string("value", ...statuses)
-				.rename("Status")
-				.describe("The updated status of the card."),
-			from: Changeable.type2.optional(),
-			created: isoly2.DateTime.type.rename("Created").describe("The time of the operation."),
-		})
-		.describe("A card operation.")
-		.rename("Operation.Card")
 }

package/Card/Operation/index.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Authorization } from "../../Authorization"
 import { Entry } from "../../Settlement/Entry"
 import { Authorization as OperationAuthorization } from "./Authorization"
@@ -28,8 +27,4 @@ export namespace Operation {
 				}
 	}
 	export const type = isly.union(Card.type, OperationAuthorization.type)
-	export const type2: isly2.Union<Operation> = isly2
-		.union<Operation>(Card.type2, OperationAuthorization.type2)
-		.rename("Operation")
-		.describe("An operation performed on a card.")
 }

package/Card/Preset.ts

@@ -1,5 +1,4 @@
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Realm } from "../Realm"
 import { Stack } from "./Stack"
 
@@ -25,10 +24,6 @@ export namespace Preset {
 		"test-diners-175",
 	] as const
 	export const type = isly.string<Preset>(names)
-	export const type2 = isly2
-		.string<Preset>("value", ...names)
-		.rename("Preset")
-		.describe("Card configuration (iin/scheme/interchange).")
 	export const forRealm: Record<Realm, Preset[]> = {
 		test: ["test-pg-150", "test-pg-200", "test-ta-mc-200", "test-ta-pg-200", "test-ta-pg-bc-200", "test-diners-175"],
 		uk: [

package/Card/Restriction/Merchant.ts

@@ -1,5 +1,4 @@
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { typedly } from "typedly"
 import { Rail } from "../../Rail"
 import { merchants } from "./merchants"
@@ -9,7 +8,6 @@ export type Merchant = (typeof Merchant.values)[number]
 export namespace Merchant {
 	export const values = typedly.Object.keys(merchants)
 	export const type = isly.string<Merchant>(values)
-	export const type2 = isly2.string<Merchant>("value", ...values)
 	export function check(merchant: Merchant, counterpart: Rail.Address.Card.Counterpart): boolean {
 		const attribute: Attribute = merchants[merchant]
 		let result: boolean

package/Card/Restriction/index.ts

@@ -1,5 +1,4 @@
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import type { Transaction } from "../../Transaction"
 import { Merchant as RestrictionsMerchant } from "./Merchant"
 
@@ -9,13 +8,6 @@ export interface Restriction {
 export namespace Restriction {
 	export import Merchant = RestrictionsMerchant
 	export const type = isly.object<Restriction>({ merchants: Merchant.type.array().optional() })
-	export const type2 = isly2.object<Restriction>({
-		merchants: Merchant.type2
-			.array()
-			.optional()
-			.rename("Merchants")
-			.describe("List of merchants that the card can be used with."),
-	})
 	export function check(
 		restrictions: Restriction,
 		transaction: Transaction.Creatable.CardTransaction | Transaction.PreTransaction.Authorization

package/Card/Restriction/merchants/Merchant.ts

@@ -1,4 +1,4 @@
-import { isly } from "isly2"
+import { isly } from "isly"
 
 export interface Merchant {
 	name: string
@@ -23,6 +23,6 @@ export namespace Merchant {
 			startsWith: value.startsWith && (Array.isArray(value.startsWith) ? value.startsWith : [value.startsWith]),
 			contains: value.contains && (Array.isArray(value.contains) ? value.contains : [value.contains]),
 		}
-		return type.prune(result)
+		return type.get(result)
 	}
 }

package/Card/Scheme.ts

@@ -1,12 +1,7 @@
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 
 export type Scheme = (typeof Scheme.schemes)[number]
 export namespace Scheme {
 	export const schemes = ["mastercard", "diners", "visa"] as const
 	export const type = isly.string<Scheme>(schemes)
-	export const type2 = isly2
-		.string<Scheme>("value", ...schemes)
-		.rename("Scheme")
-		.describe("Card scheme.")
 }

package/Card/index.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Amount } from "../Amount"
 import { Realm } from "../Realm"
 import { Report } from "../Report"
@@ -76,42 +75,6 @@ export namespace Card {
 		meta: isly.fromIs("Card.Meta", CardMeta.is).optional(),
 		restricted: isly.object<Required<Card>["restricted"]>({ to: CardRestriction.type.optional() }).optional(),
 	})
-	export const type2: isly2.Object<Card> = isly2
-		.object<Card>({
-			id: isly2.string().rename("Id").describe("Unique 16 character base 64 identifier."),
-			number: isly2.string().optional().rename("Number").describe("Api users identifier."),
-			created: isly2.string().rename("Created").describe("Date and time of creation."),
-			organization: isly2.string().rename("Organization").describe("Organization code."),
-			realm: Realm.type2,
-			account: isly2.string().rename("Account").describe("Account identifier."),
-			preset: CardPreset.type2,
-			scheme: CardScheme.type2,
-			reference: isly2.string().rename("Reference").describe("Reference to external system."),
-			details: isly2.object<Card["details"]>({
-				iin: isly2.string().rename("Iin").describe("First 6-8 numbers of the pan."),
-				last4: isly2.string().rename("Last4").describe("Last four digits of pan."),
-				expiry: CardExpiry.type2,
-				holder: isly2.string().rename("Holder").describe("Card holder name."),
-				token: isly2.string().optional().rename("Token").describe("Encrypted token of the card."),
-			}),
-			limit: Amount.type2.rename("Limit").describe("Maximum amount that can be spent on the card."),
-			spent: Amount.type2.rename("Spent").describe("Amount spent on the card."),
-			status: isly2.string("value", ["active", "cancelled"]).rename("Status").describe("Current card status."),
-			history: CardOperation.type2.array().rename("History").describe("Card operation history."),
-			rules: isly2
-				.from("Rule", ruleType.is)
-				.array()
-				.rename("Rules")
-				.describe("Card rules that applies to authorizations made with the card."),
-			meta: isly2.from("Card.Meta", CardMeta.is).optional().rename("Meta").describe("Additional card information."),
-			restricted: isly2
-				.object<Required<Card>["restricted"]>({ to: CardRestriction.type2.optional() })
-				.optional()
-				.rename("Restrictions")
-				.describe("Set of restrictions that apply to the card."),
-		})
-		.rename("Card")
-		.describe("Card information.")
 	const csvMap: Record<string, (card: Card) => string | number | undefined> = {
 		id: card => card.id,
 		created: card => readableDate(card.created),

package/Client/Transactions/index.ts

@@ -1,7 +1,6 @@
 import { gracely } from "gracely"
 import { isoly } from "isoly"
 import { http } from "cloudly-http"
-import { isly } from "isly2"
 import { Card } from "../../Card"
 import { Operation } from "../../Operation"
 import { Rail } from "../../Rail"
@@ -62,24 +61,4 @@ export namespace Transactions {
 		rail?: Rail
 		type?: Transaction.Types
 	}
-	export namespace Query {
-		export const type = isly.object({
-			id: isly.string().optional(),
-			account: isly.string().optional(),
-			limit: isly.number().optional(),
-			cursor: isly.string().optional(),
-			start: isly.string().optional(),
-			end: isly.string().optional(),
-			currency: isly.string().optional(),
-			organization: isly.string().optional(),
-			rail: Rail.type2.optional(),
-			type: isly.string("value", ...Transaction.types).optional(),
-		})
-		export function parse(query: string | http.Request["search"]): Query {
-			if (typeof query == "string") {
-				query = query ? http.Search.parse(query.replace("?", "")) : {}
-			} // search.parse does not support empty string
-			return type.prune(query) ?? {}
-		}
-	}
 }

package/Operation/Changes.ts

@@ -6,6 +6,12 @@ import { Change } from "./Change"
 
 export type Changes = Partial<Record<Changes.Entry.Balance, Change>>
 export namespace Changes {
+	export function balance(currency: isoly.Currency, changes: Changes): number {
+		return [changes.available, changes["reserved-incoming"], changes["reserved-outgoing"]].reduce(
+			(r, change) => isoly.Currency.add(currency, r, (change?.type == "subtract" ? -1 : 1) * (change?.amount ?? 0)),
+			0
+		)
+	}
 	export function available(changes: MaybeLegacy, currency: isoly.Currency, legacy: boolean = false): number {
 		return legacy
 			? Object.entries(changes).reduce(

package/Rail/index.ts

@@ -1,5 +1,4 @@
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Address as RailAddress } from "./Address"
 
 export type Rail = (typeof Rail.rails)[number]
@@ -18,6 +17,5 @@ export namespace Rail {
 		"credit",
 	] as const
 	export const type = isly.string<Rail>(rails)
-	export const type2 = isly2.string<Rail>("value", ...rails)
 	export import Address = RailAddress
 }

package/Realm.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Supplier as modelSupplier } from "./Supplier"
 import { zod } from "./zod"
 
@@ -10,10 +9,6 @@ export namespace Realm {
 	export const realms = ["test", "uk", "eea"] as const
 	export const type = isly.string<Realm>(realms)
 	export const typeZod = zod.enum(realms)
-	export const type2 = isly2
-		.string<Realm>("value", ...realms)
-		.rename("Realm")
-		.describe("Financial jurisdiction.")
 	export function toString(): string {
 		return realms.toString().replaceAll(",", ", ") + "."
 	}

package/Rule/Base.ts

@@ -1,5 +1,4 @@
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import { Preset } from "../Card/Preset"
 
 export interface Base {
@@ -18,10 +17,6 @@ export namespace Base {
 	export namespace Kind {
 		export const values = ["authorization", "outbound", "inbound", "capture", "refund"] as const
 		export const type = isly.string<Kind>(values)
-		export const type2 = isly2
-			.string<Kind>("value", ...values)
-			.rename("Kind")
-			.describe("The type of the rule.")
 		export function is(kind: Kind, rule: Base, groups: string[] | undefined, preset: Preset | undefined): boolean {
 			const applyRuleForGroup =
 				!rule.groups || rule.groups.some(ruleGroup => groups?.some(organizationGroup => organizationGroup == ruleGroup))
@@ -33,10 +28,6 @@ export namespace Base {
 	export namespace Category {
 		export const values = ["fincrime", "product", "customer"] as const
 		export const type = isly.string<Category>(values)
-		export const type2 = isly2
-			.string<Category>("value", ...values)
-			.rename("Category")
-			.describe("The category of the rule.")
 	}
 	export const type = isly.object<Base>({
 		code: isly.string(/^[a-z0-9\-_]+$/),
@@ -49,21 +40,4 @@ export namespace Base {
 		groups: isly.string().array().optional(),
 		presets: Preset.type.array().optional(),
 	})
-	export const type2 = isly2.object<Base>({
-		code: isly2
-			.string("value", /^[a-z0-9\-_]+$/)
-			.rename("Code")
-			.describe("The unique identifier of the rule."),
-		name: isly2.string().rename("Name").describe("The name of the rule."),
-		description: isly2.string().rename("Description").describe("The description of the rule."),
-		type: Kind.type2,
-		category: Category.type2,
-		condition: isly2
-			.string()
-			.rename("Condition")
-			.describe("The condition to evaluate, determines if the action is applied or not."),
-		flags: isly2.string().array().rename("Flags").describe("The flags to set when the rule is applied."),
-		groups: isly2.string().array().optional().rename("Groups").describe("The groups the rule applies to."),
-		presets: Preset.type2.array().optional().rename("Presets").describe("The presets the rule applies to."),
-	})
 }

package/Rule/Other.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { isly as isly2 } from "isly2"
 import type { Note } from "../Transaction/Note"
 import { Base } from "./Base"
 import { control } from "./control"
@@ -14,13 +13,8 @@ export namespace Other {
 	export namespace Action {
 		export const values = ["review", "reject", "flag"] as const
 		export const type = isly.string<Action>(values)
-		export const type2 = isly2
-			.string<Action>("value", ...values)
-			.rename("Action")
-			.describe("The action to take when the rule is applied.")
 	}
 	export const type = Base.type.extend<Other>({ action: Action.type })
-	export const type2: isly2.Object<Other> = Base.type2.extend<Other>({ action: Action.type2 })
 	export function evaluate(
 		rules: Other[],
 		state: State

package/Rule/type.ts

@@ -1,8 +1,3 @@
-// import { isly as isly2 } from "isly2"
 import { Other } from "./Other"
 
 export const type = Other.type
-// TODO: Implement type2
-// export const type2 = isly2
-// 	.union<Rule, Other, Score, Charge.Api, Reserve>(Other.type2, Score.type2, Charge.Api.type2, Reserve.type2)
-// 	.describe("Changes what how the rules is applied.")

package/Treasury/Snapshot/Account.ts

@@ -9,7 +9,7 @@ export interface Account {
 	reference: string
 	description?: string
 	currency: isoly.Currency
-	opening: Account.Opening
+	opening?: Account.Opening
 	closing: Account.Closing
 	delta: Account.Delta
 	warnings?: Warning.Snapshot[]

package/Treasury/Snapshot/Check/BankFeedIntegrity.ts

@@ -0,0 +1,19 @@
+import { isoly } from "isoly"
+import { Base } from "./Base"
+import { Result } from "./Result"
+
+export interface BankFeedIntegrity extends Base {
+	check: "bank feed integrity"
+	accounts: {
+		code: string
+		reference: string
+		supplier: string
+		opening?: { at: isoly.DateTime; balance: number }
+		transaction?: { balance: number }
+		closing: { at: isoly.DateTime; balance: number }
+		timestamp: string
+		result: Result
+	}[]
+}
+
+export namespace BankFeedIntegrity {}

package/Treasury/Snapshot/Check/Base.ts

@@ -0,0 +1,8 @@
+import { Checks } from "./Checks"
+import { Result } from "./Result"
+
+export interface Base {
+	check: Checks
+	result: Result
+}
+export namespace Base {}

package/Treasury/Snapshot/Check/Checks.ts

@@ -0,0 +1,15 @@
+import { isly } from "isly"
+
+export type Checks = (typeof Checks.value)[number]
+export namespace Checks {
+	export const value = [
+		"bank feed integrity", // Proves Bank Prev Balance + Bank Txns = Bank Current Balance
+		"external reconciliation", // Proves Internal Safeguard Mirror matches Actual Bank Balance
+		"internal reconciliation", // Proves Total E-Money Liabilities match Internal Safeguard Mirror
+		"ledger integrity", // Proves Opening Balance + Operations = Closing Balance
+		"overdraft", // Warns if any customer accounts fall below zero
+		"transaction match", // Proves all external bank txns have a 1:1 internal ledger txn
+		"unidentified funds", // Flags any received money not yet assigned to a customer
+	] as const
+	export const type = isly.string(value)
+}

package/Treasury/Snapshot/Check/ExternalReconciliation.ts

@@ -0,0 +1,9 @@
+import { Base } from "./Base"
+
+export interface ExternalReconciliation extends Base {
+	check: "external reconciliation"
+	counterbalance: number
+	fiat: number
+	discrepancy: number
+}
+export namespace ExternalReconciliation {}

package/Treasury/Snapshot/Check/InternalReconciliation.ts

@@ -0,0 +1,9 @@
+import { Base as ResultBase } from "./Base"
+
+export interface InternalReconciliation extends ResultBase {
+	check: "internal reconciliation"
+	counterbalance: number
+	emoney: number
+	discrepancy: number
+}
+export namespace InternalReconciliation {}

package/Treasury/Snapshot/Check/LedgerIntegrity.ts

@@ -0,0 +1,17 @@
+import { isoly } from "isoly"
+import { Base } from "./Base"
+import { Result } from "./Result"
+
+export interface LedgerIntegrity extends Base {
+	check: "ledger integrity"
+	accounts: {
+		id: string
+		organization: string
+		timestamp: string
+		opening?: { at: isoly.DateTime; balance: number }
+		ledger?: { change: number }
+		closing: { at: isoly.DateTime; balance: number }
+		result: Result
+	}[]
+}
+export namespace LedgerIntegrity {}

package/Treasury/Snapshot/Check/Overdraft.ts

@@ -0,0 +1,7 @@
+import { Base } from "./Base"
+
+export interface Overdraft extends Base {
+	check: "overdraft"
+	overdrafts: { account: string; balance: number }[]
+}
+export namespace Overdraft {}

package/Treasury/Snapshot/Check/Result.ts

@@ -0,0 +1,11 @@
+export type Result = "passed" | "failed" | "incomplete"
+export namespace Result {
+	export const precedence: Record<Result, number> = {
+		failed: 3,
+		incomplete: 2,
+		passed: 1,
+	}
+	export function aggregate(results: Result[]): Result {
+		return results.reduce((r, e) => (precedence[e] > precedence[r] ? e : r), "passed")
+	}
+}

package/Treasury/Snapshot/Check/TransactionMatch.ts

@@ -0,0 +1,9 @@
+import { Base } from "./Base"
+
+export interface TransactionMatch extends Base {
+	check: "transaction match"
+	total: number
+	matched: number
+	unmatched: string[]
+}
+export namespace TransactionMatch {}

package/Treasury/Snapshot/Check/UnidentifiedFunds.ts

@@ -0,0 +1,8 @@
+import { Base as ResultBase } from "./Base"
+
+export interface UnidentifiedFunds extends ResultBase {
+	check: "unidentified funds"
+	account: string
+	balance: number
+}
+export namespace UnidentifiedFunds {}

package/Treasury/Snapshot/Check/index.ts

@@ -0,0 +1,29 @@
+import { BankFeedIntegrity as CheckBankFeedIntegrity } from "./BankFeedIntegrity"
+import { Checks as CheckChecks } from "./Checks"
+import { ExternalReconciliation as CheckExternalReconciliation } from "./ExternalReconciliation"
+import { InternalReconciliation as CheckInternalReconciliation } from "./InternalReconciliation"
+import { LedgerIntegrity as CheckLedgerIntegrity } from "./LedgerIntegrity"
+import { Overdraft as CheckOverdraft } from "./Overdraft"
+import { Result as CheckResult } from "./Result"
+import { TransactionMatch as CheckTransactionMatch } from "./TransactionMatch"
+import { UnidentifiedFunds as CheckUnidentifiedFunds } from "./UnidentifiedFunds"
+
+export type Check =
+	| Check.BankFeedIntegrity
+	| Check.ExternalReconciliation
+	| Check.InternalReconciliation
+	| Check.LedgerIntegrity
+	| Check.Overdraft
+	| Check.TransactionMatch
+	| Check.UnidentifiedFunds
+export namespace Check {
+	export import Result = CheckResult
+	export import Checks = CheckChecks
+	export type BankFeedIntegrity = CheckBankFeedIntegrity
+	export type ExternalReconciliation = CheckExternalReconciliation
+	export type InternalReconciliation = CheckInternalReconciliation
+	export type LedgerIntegrity = CheckLedgerIntegrity
+	export type Overdraft = CheckOverdraft
+	export type TransactionMatch = CheckTransactionMatch
+	export type UnidentifiedFunds = CheckUnidentifiedFunds
+}

package/Treasury/Snapshot/Fiat.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly"
 import { Supplier } from "../../Supplier"
-import { Warning } from "../../Warning"
 import { Balance } from "../Balance"
 
 export interface Fiat {
@@ -9,7 +8,6 @@ export interface Fiat {
 	timestamp: isoly.DateTime
 	type: "safeguarded" | "unsafe" | "other" | "buffer"
 	balances: Balance
-	warnings?: Warning.Snapshot[]
 	conditions?: { minimum?: Balance }
 	label?: string
 	reference: string