@pax2pay/model-banking 0.1.602 → 0.1.604

package/Rule/Base.ts

@@ -14,7 +14,7 @@ export interface Base {
 	presets?: Preset[]
 }
 export namespace Base {
-	export type Kind = typeof Kind.values[number]
+	export type Kind = (typeof Kind.values)[number]
 	export namespace Kind {
 		export const values = ["authorization", "outbound", "inbound", "capture", "refund"] as const
 		export const type = isly.string<Kind>(values)
@@ -29,7 +29,7 @@ export namespace Base {
 			return kind == rule.type && applyRuleForGroup && applyRuleForPreset
 		}
 	}
-	export type Category = typeof Category.values[number]
+	export type Category = (typeof Category.values)[number]
 	export namespace Category {
 		export const values = ["fincrime", "product", "customer"] as const
 		export const type = isly.string<Category>(values)

package/Rule/Other.ts

@@ -10,7 +10,7 @@ export interface Other extends Base {
 	action: Other.Action
 }
 export namespace Other {
-	export type Action = typeof Action.values[number]
+	export type Action = (typeof Action.values)[number]
 	export namespace Action {
 		export const values = ["review", "reject", "flag"] as const
 		export const type = isly.string<Action>(values)
@@ -38,14 +38,16 @@ export namespace Other {
 		if (
 			state.transaction.stage == "initiate" &&
 			["card", "external", "internal"].some(type => type == state.transaction.type)
-		)
-			for (const rule of rules)
+		) {
+			for (const rule of rules) {
 				if (control(rule, state)) {
 					result.outcomes[rule.action].push(rule)
 					result.notes.push({ author: "automatic", created: now, text: rule.name, rule })
 					rule.flags.forEach(f => result.flags.add(f))
 					rule.action == "review" && result.flags.add("review")
 				}
+			}
+		}
 		return result
 	}
 }

package/Rule/State/Authorization.ts

@@ -41,7 +41,7 @@ export namespace Authorization {
 						typeof transaction.reference == "string" ? transaction.reference : transaction.reference?.reference,
 					description: transaction.description,
 					...("exchange" in transaction ? { exchange: transaction.exchange } : {}),
-			  }
+				}
 			: undefined
 	}
 	export function toTransaction(authorization: Authorization): Transaction.Creatable & {

package/Rule/State/Card.ts

@@ -34,10 +34,11 @@ export namespace Card {
 	}
 	export function check(card: Card, amount: number): TransactionStatus.Reason | undefined {
 		let result: TransactionStatus.Reason | undefined = undefined
-		if (ModelCard.Expiry.isExpired(card.details.expiry))
+		if (ModelCard.Expiry.isExpired(card.details.expiry)) {
 			result = "card expired"
-		else if (amount + card.spent[1] > card.limit)
+		} else if (amount + card.spent[1] > card.limit) {
 			result = "exceeds limit"
+		}
 		return result
 	}
 	export function toAddress(card: Card): Rail.Address.Card {

package/Rule/State/index.ts

@@ -25,7 +25,7 @@ export namespace State {
 	export import Account = StateAccount
 	export import Transaction = StateTransaction
 	export import Organization = StateOrganization
-	export type Outcome = typeof Outcome.values[number]
+	export type Outcome = (typeof Outcome.values)[number]
 	export namespace Outcome {
 		export const values = ["approve", "reject", "review"] as const
 		export const type = isly.string<Outcome>(values)

package/Rule/index.ts

@@ -15,7 +15,7 @@ export namespace Rule {
 	export import Category = Base.Category
 	export const control = ruleControl
 
-	export type Action = typeof Action.values[number]
+	export type Action = (typeof Action.values)[number]
 	export namespace Action {
 		export const values = [...Other.Action.values] as const
 		export const type = isly.string<Action>(values)

package/Settlement/Entry/fromCreatable.ts

@@ -11,17 +11,19 @@ export function fromCreatable(
 	let result: Entry
 	const reasons: string[] = []
 	const created = isoly.DateTime.now()
-	if (creatable.type == "unknown")
+	if (creatable.type == "unknown") {
 		reasons.push("Unknown entry type.")
-	if (gracely.Error.is(transaction))
+	}
+	if (gracely.Error.is(transaction)) {
 		reasons.push(`gracely error: ${JSON.stringify(transaction)}`)
-	else if (typeof transaction == "string")
+	} else if (typeof transaction == "string") {
 		reasons.push(transaction || "No reason provided.")
-	else if (transaction.status != "finalized" && transaction.status != "processing")
+	} else if (transaction.status != "finalized" && transaction.status != "processing") {
 		reasons.push(`Transaction ${transaction.id} on account ${transaction.accountId} unable to be finalized.`)
-	if (reasons.length > 0)
+	}
+	if (reasons.length > 0) {
 		result = { status: "failed", reason: reasons.join("\n"), ...creatable, created }
-	else {
+	} else {
 		const cardTransaction = transaction as Transaction.CardTransaction
 		result = {
 			status: "succeeded",

package/Settlement/Status.ts

@@ -7,7 +7,7 @@ export interface Status {
 
 export namespace Status {
 	export const values = ["pending", "failed", "partial", "done"] as const
-	export type Values = typeof values[number]
+	export type Values = (typeof values)[number]
 	export const type = isly.object<Status>({
 		collected: isly.string(values),
 		settled: isly.string(values),

package/Settlement/Total.ts

@@ -52,26 +52,28 @@ export namespace Total {
 	export function add(currency: isoly.Currency, addendee: Total, addend: Partial<Total>): Total {
 		const result: Total = { ...addendee }
 		addend.expected && (result.expected = Amount.add(currency, result.expected, addend.expected))
-		if (result.outcome || addend.outcome)
+		if (result.outcome || addend.outcome) {
 			result.outcome = Amount.add(currency, result.outcome ?? { net: 0, fee: { other: 0 } }, addend.outcome ?? {})
+		}
 		if (result.collected || addend.collected) {
 			const transactions1 = Array.isArray(result.collected?.transactions)
 				? result.collected.transactions
 				: result.collected?.transactions
-				? [result.collected.transactions]
-				: []
+					? [result.collected.transactions]
+					: []
 			const transactions2 = Array.isArray(addend.collected?.transactions)
 				? addend.collected.transactions
 				: addend.collected?.transactions
-				? [addend.collected.transactions]
-				: []
+					? [addend.collected.transactions]
+					: []
 			result.collected = { transactions: [...transactions1, ...transactions2] }
 		}
-		if (result.settled || addend.settled)
+		if (result.settled || addend.settled) {
 			result.settled = {
 				net: addend.settled?.net ?? result.settled?.net ?? 0,
 				transactions: result.settled?.transactions ?? addend.settled?.transactions ?? [],
 			}
+		}
 		return result
 	}
 }

package/Settlement/Totals.ts

@@ -8,7 +8,7 @@ export namespace Totals {
 	export const type = isly.record<isoly.Currency, Total>(isly.string(isoly.Currency.values), Total.type)
 	export function addEntry(totals: Totals, entry: Entry): Totals {
 		const result = { ...totals }
-		if (entry.status == "succeeded" && (entry.type == "capture" || entry.type == "refund"))
+		if (entry.status == "succeeded" && (entry.type == "capture" || entry.type == "refund")) {
 			result[entry.amount[0]] = Total.add(entry.amount[0], result[entry.amount[0]] ?? Total.create(), {
 				outcome: {
 					net: entry.amount[1],
@@ -16,6 +16,7 @@ export namespace Totals {
 					fee: { other: entry.fee.other[entry.amount[0]] ?? 0 },
 				},
 			})
+		}
 		return result
 	}
 	export function verify(totals: Totals, type: "outcome" | "settled"): boolean {
@@ -23,8 +24,9 @@ export namespace Totals {
 	}
 	export function add(addendee: Totals, addends: Partial<Record<isoly.Currency, Partial<Total>>>): Totals {
 		const result = { ...addendee }
-		for (const [currency, addend] of Object.entries(addends) as [isoly.Currency, Partial<Total>][])
+		for (const [currency, addend] of Object.entries(addends) as [isoly.Currency, Partial<Total>][]) {
 			result[currency] = Total.add(currency, result[currency] ?? Total.create(), addend)
+		}
 		return result
 	}
 }

package/Supplier/index.ts

@@ -2,7 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Realm } from "../Realm"
 
-export type Supplier = typeof Supplier.names[number]
+export type Supplier = (typeof Supplier.names)[number]
 export namespace Supplier {
 	export const names = ["paxgiro", "clearbank", "bankingcircle"] as const
 	export const type = isly.string<Supplier>(names)
@@ -21,6 +21,5 @@ export namespace Supplier {
 		eea: [],
 		test: ["paxgiro", "bankingcircle"],
 		uk: ["clearbank", "bankingcircle"],
-	// eslint-disable-next-line prettierx/options
 	} as const satisfies Record<Realm, Supplier[]>
 }

package/Transaction/Statistics.ts

@@ -12,11 +12,11 @@ export interface Statistics {
 }
 
 export namespace Statistics {
-	export type TransactionType = typeof TransactionType.values[number]
+	export type TransactionType = (typeof TransactionType.values)[number]
 	export namespace TransactionType {
 		export const values = ["capture", "refund"] as const
 	}
-	export type Region = typeof Region.values[number]
+	export type Region = (typeof Region.values)[number]
 	export namespace Region {
 		export const values = ["domestic", "intraRegion", "extraRegion"] as const
 	}
@@ -54,7 +54,7 @@ export namespace Statistics {
 		regions: Record<"domestic" | "intraRegion", isoly.CountryCode.Alpha2[]>
 	): Statistics {
 		const result: Statistics = empty()
-		for (const transaction of transactions)
+		for (const transaction of transactions) {
 			if (
 				Transaction.CardTransaction.type.is(transaction) &&
 				transaction.status == "finalized" &&
@@ -63,8 +63,8 @@ export namespace Statistics {
 				const region = regions.domestic.includes(transaction.counterpart.merchant.country)
 					? "domestic"
 					: regions.intraRegion.includes(transaction.counterpart.merchant.country)
-					? "intraRegion"
-					: "extraRegion"
+						? "intraRegion"
+						: "extraRegion"
 				const kind = transaction.direction == "outbound" ? "capture" : "refund"
 				result[kind][region].count++
 				result[kind][region].amount = isoly.Currency.add(
@@ -74,6 +74,7 @@ export namespace Statistics {
 				)
 				result.cards.includes(transaction.account.id) || result.cards.push(transaction.account.id)
 			}
+		}
 		return result
 	}
 	export function combine(accumulation: Statistics, incoming: Statistics, currency: isoly.Currency): Statistics {

package/Transaction/Status.ts

@@ -4,10 +4,10 @@ export type Status = Status.Success | [Status.Fail, Status.Reason]
 export namespace Status {
 	// DEPRECATED: "created"
 	export const successes = ["created", "review", "processing", "finalized"] as const
-	export type Success = typeof successes[number]
+	export type Success = (typeof successes)[number]
 	export const Success = isly.string<Success>(successes)
 	export const failures = ["rejected", "cancelled"] as const
-	export type Fail = typeof failures[number]
+	export type Fail = (typeof failures)[number]
 	export const Fail = isly.string<Fail>(failures)
 	export const reasons = [
 		"insufficient funds",
@@ -21,7 +21,7 @@ export namespace Status {
 		"denied",
 		"merchant lock violation",
 	] as const
-	export type Reason = typeof reasons[number]
+	export type Reason = (typeof reasons)[number]
 	export const Reason = isly.string<Reason>(reasons)
 	export const type = isly.union<Status, Success, [Fail, Status.Reason]>(
 		Success,

package/Transaction/index.ts

@@ -48,9 +48,9 @@ export namespace Transaction {
 	export import Exchange = TransactionExchange
 	export import Amount = TransactionAmount
 	export const types = ["card", "internal", "external", "system"] as const
-	export type Types = typeof types[number]
+	export type Types = (typeof types)[number]
 	export const directions = ["inbound", "outbound"] as const
-	export type Direction = typeof directions[number]
+	export type Direction = (typeof directions)[number]
 	export import Creatable = TransactionCreatable
 	export import PreTransaction = TransactionPreTransaction
 	export import Reference = TransactionReference
@@ -118,7 +118,7 @@ export namespace Transaction {
 							charge: 0,
 							total: transaction.state?.transaction.original.total ?? transaction.amount,
 						},
-				  }
+					}
 				: { amount: transaction.amount }),
 		}
 	}
@@ -153,17 +153,17 @@ export namespace Transaction {
 			typeof operation == "string"
 				? ["rejected", operation]
 				: state.outcome == "reject"
-				? ["rejected", "denied"]
-				: state.outcome == "review"
-				? "review"
-				: "processing"
+					? ["rejected", "denied"]
+					: state.outcome == "review"
+						? "review"
+						: "processing"
 		const rail: Rail = state.card
 			? state.card.scheme
 			: account.address.type == "internal"
-			? "internal"
-			: account.address.type == "paxgiro"
-			? "paxgiro"
-			: "fasterpayments"
+				? "internal"
+				: account.address.type == "paxgiro"
+					? "paxgiro"
+					: "fasterpayments"
 		return {
 			...creatable,
 			amount: Amount.fromState(state, charges, quote),
@@ -330,7 +330,7 @@ export namespace Transaction {
 	export function flag(transaction: Transaction, flags: string[] | undefined): void {
 		const current = new Set<string>(transaction.flags)
 		const old = new Set<string>(transaction.oldFlags)
-		for (const flag of flags ?? [])
+		for (const flag of flags ?? []) {
 			if (!flag.startsWith("-")) {
 				old.delete(flag)
 				current.add(flag)
@@ -338,6 +338,7 @@ export namespace Transaction {
 				current.delete(flag.substring(1))
 				old.add(flag.substring(1))
 			}
+		}
 		transaction.flags = Array.from(current)
 		transaction.oldFlags = Array.from(old)
 	}
@@ -350,14 +351,15 @@ export namespace Transaction {
 			accountName.startsWith("net-") ||
 			accountName.startsWith("interchange-") ||
 			accountName.startsWith("collect-")
-		)
+		) {
 			result = "system"
-		else if (counterpart.type == "internal")
+		} else if (counterpart.type == "internal") {
 			result = "internal"
-		else if (counterpart.type == "card")
+		} else if (counterpart.type == "card") {
 			result = "card"
-		else
+		} else {
 			result = "external"
+		}
 		return result
 	}
 
@@ -392,15 +394,15 @@ export namespace Transaction {
 		return address.type != "card"
 			? Rail.Address.stringify(address)
 			: Rail.Address.Card.Counterpart.type.is(address)
-			? `${address.merchant.category} ${address.merchant.name}`
-			: `${address.iin}******${address.last4}`
+				? `${address.merchant.category} ${address.merchant.name}`
+				: `${address.iin}******${address.last4}`
 	}
 	function railAddressId(address: Rail.Address): string {
 		return address.type != "card"
 			? Rail.Address.stringify(address)
 			: Rail.Address.Card.Counterpart.type.is(address)
-			? address.merchant.id
-			: address.id
+				? address.merchant.id
+				: address.id
 	}
 	export function toCsv(transactions: (Transaction | Transaction.Legacy)[]): string {
 		return Report.toCsv(

package/Treasury/Account/Category.ts

@@ -1,6 +1,6 @@
 import { isly } from "isly"
 
-export type Category = typeof Category.name[number]
+export type Category = (typeof Category.name)[number]
 export namespace Category {
 	export const name = ["safeguarded", "unsafe", "buffer", "other", "external"] as const
 	export const type = isly.string(name)

package/Treasury/Snapshot/funding.ts

@@ -21,23 +21,24 @@ export namespace funding {
 		export const type = isly.record<Cursors>(isly.fromIs("isoly.Currency", isoly.Currency.is), Cursor.type)
 		export function updateAmount(settlement: Transaction, cursors: Cursors): Cursors {
 			const cursor = cursors[settlement.currency]
-			if (!cursor)
+			if (!cursor) {
 				cursors[settlement.currency] = {
 					cursor: Cursor.fromTransaction(settlement),
 					amount: Math.abs(settlement.amount),
 				}
-			else
+			} else {
 				cursor.amount += Math.abs(settlement.amount)
+			}
 			return cursors
 		}
 		export function updateCursors(funding: Transaction, cursors: Cursors): Cursors {
 			const cursor = cursors[funding.currency]
-			if (!cursor)
+			if (!cursor) {
 				cursors[funding.currency] = {
 					cursor: Cursor.fromTransaction(funding),
 					amount: -Math.abs(funding.amount),
 				}
-			else if (cursor.amount > 0) {
+			} else if (cursor.amount > 0) {
 				cursor.amount -= Math.abs(funding.amount)
 				cursor.cursor = Cursor.fromTransaction(funding)
 			}
@@ -45,8 +46,9 @@ export namespace funding {
 		}
 	}
 	export function settle(transactions: Transaction[], amountsUpdated: Cursors): Cursors {
-		for (let i = transactions.length - 1; i >= 0; i--)
+		for (let i = transactions.length - 1; i >= 0; i--) {
 			Cursors.updateCursors(transactions[i], amountsUpdated)
+		}
 		return amountsUpdated
 	}
 	export function isStale(cursor: Cursor, bankingDays?: number, holidays?: isoly.Date[]): boolean {

package/User/Access/Permission.ts

@@ -30,7 +30,7 @@ export namespace Permission {
 	}
 	export type Collection = zod.infer<typeof Collection.typeZod>
 	export namespace Collection {
-		export type Realm = typeof Realm.values[number]
+		export type Realm = (typeof Realm.values)[number]
 		export namespace Realm {
 			export const values = [
 				"*",
@@ -44,7 +44,7 @@ export namespace Permission {
 				"treasury",
 			] as const
 		}
-		export type Global = typeof Global.values[number]
+		export type Global = (typeof Global.values)[number]
 		export namespace Global {
 			export const values = ["user"] as const
 		}

package/User/Identity.ts

@@ -8,14 +8,18 @@ export class Identity {
 	get realm(): Realm {
 		return this.payload.realm
 	}
-	constructor(public readonly payload: JWT.Payload, public readonly jwt: string) {}
+	constructor(
+		public readonly payload: JWT.Payload,
+		public readonly jwt: string
+	) {}
 
 	authenticate(constraint: Access.Permission | Access.Permission[]): Identity | gracely.Error {
 		let allowed: boolean
-		if (Array.isArray(constraint))
+		if (Array.isArray(constraint)) {
 			allowed = constraint.some(c => this.authenticate(c))
-		else
+		} else {
 			allowed = Access.Permission.check(constraint, this.payload.permission)
+		}
 		return allowed ? this : gracely.client.forbidden()
 	}
 

package/User/Password.ts

@@ -20,14 +20,15 @@ export namespace Password {
 	}
 	export async function create(creatable: Creatable, pepper: string | undefined): Promise<Password | gracely.Error> {
 		let result: Awaited<ReturnType<typeof create>>
-		if (creatable.new !== creatable.repeat)
+		if (creatable.new !== creatable.repeat) {
 			result = gracely.client.forbidden("The new password and the repeated password do not match.")
-		else if (creatable.new.length < 8)
+		} else if (creatable.new.length < 8) {
 			result = gracely.client.forbidden("The new password must be at least 8 characters long.")
-		else if (!pepper)
+		} else if (!pepper) {
 			result = gracely.server.backendFailure("The password cannot be created without a pepper.")
-		else
+		} else {
 			result = { hash: await hash(creatable.new, pepper), changed: isoly.DateTime.now() }
+		}
 		return result
 	}
 	export function salt(): string {

package/Warning/Base.ts

@@ -12,7 +12,7 @@ export interface Base {
 }
 
 export namespace Base {
-	export type Severity = typeof Severity.values[number]
+	export type Severity = (typeof Severity.values)[number]
 	export namespace Severity {
 		export const values = ["low", "medium", "high"] as const
 		export const type = isly.string<Severity>(values)

package/Warning/Snapshot/MissingBuffer.ts

@@ -22,7 +22,7 @@ export namespace MissingBuffer {
 		const result: MissingBuffer[] = []
 		for (const [currency, amount] of Object.entries(account.balance)) {
 			const minimum = account.conditions?.minimum?.[currency as isoly.Currency]
-			if (typeof minimum != "undefined" && minimum > amount)
+			if (typeof minimum != "undefined" && minimum > amount) {
 				result.push({
 					type: "missing-buffer",
 					resource: account.code,
@@ -31,6 +31,7 @@ export namespace MissingBuffer {
 					balance: amount,
 					date: isoly.Date.now(),
 				})
+			}
 		}
 		return result
 	}

package/Warning/Snapshot/StaleFiat.ts

@@ -22,7 +22,7 @@ export namespace StaleFiat {
 		for (const [currency, amount] of Object.entries(account.balance)) {
 			let oldest: { id: string; date: isoly.Date; created: isoly.DateTime } | undefined = undefined
 			let remainder = amount
-			for (const transaction of transactions)
+			for (const transaction of transactions) {
 				if (transaction.amount > 0 && transaction.currency == currency && remainder > 0) {
 					remainder = isoly.Currency.subtract(currency, remainder, transaction.amount)
 					oldest = {
@@ -30,9 +30,11 @@ export namespace StaleFiat {
 						date: isoly.DateTime.getDate(transaction.created),
 						created: transaction.created,
 					}
-				} else if (remainder < 0)
+				} else if (remainder < 0) {
 					break
-			if (oldest && isoly.Date.now() > isoly.Date.nextBusinessDay(oldest.date, 3, Holidays.dates["England"]))
+				}
+			}
+			if (oldest && isoly.Date.now() > isoly.Date.nextBusinessDay(oldest.date, 3, Holidays.dates["England"])) {
 				result.push({
 					type: "stale-fiat",
 					currency: currency as isoly.Currency,
@@ -40,6 +42,7 @@ export namespace StaleFiat {
 					transaction: { id: oldest.id, created: oldest.created },
 					resource: oldest.id,
 				})
+			}
 		}
 		return result
 	}

package/dist/cjs/Account/Charge/Fx/index.js

@@ -10,12 +10,13 @@ var Fx;
         let result;
         const chargePreset = preset && charge[preset] ? preset : "default";
         const chargeRate = charge[chargePreset] ?? 0;
-        if (exchange)
+        if (exchange) {
             result = {
                 preset: chargePreset,
                 rate: chargeRate,
                 amount: -isoly_1.isoly.Currency.multiply(currency, amount, chargeRate),
             };
+        }
         return result;
     }
     Fx.evaluate = evaluate;

package/dist/cjs/Account/Charge/Fx/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Fx/index.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAI7B,sCAAkC;AAIlC,IAAiB,EAAE,CAoBlB;AApBD,WAAiB,EAAE;IACL,OAAI,GAAG,eAAM,CAAC,IAAI,CAAA;IAC/B,SAAgB,QAAQ,CACvB,MAAU,EACV,QAAwB,EACxB,MAAc,EACd,MAAoB,EACpB,QAAmB;QAEnB,IAAI,MAAoC,CAAA;QACxC,MAAM,YAAY,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAA;QAClE,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC5C,IAAI,QAAQ;YACX,MAAM,GAAG;gBACR,MAAM,EAAE,YAAY;gBACpB,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC;aAC9D,CAAA;QACF,OAAO,MAAM,CAAA;IACd,CAAC;IAjBe,WAAQ,WAiBvB,CAAA;AACF,CAAC,EApBgB,EAAE,kBAAF,EAAE,QAoBlB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Fx/index.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAI7B,sCAAkC;AAIlC,IAAiB,EAAE,CAqBlB;AArBD,WAAiB,EAAE;IACL,OAAI,GAAG,eAAM,CAAC,IAAI,CAAA;IAC/B,SAAgB,QAAQ,CACvB,MAAU,EACV,QAAwB,EACxB,MAAc,EACd,MAAoB,EACpB,QAAmB;QAEnB,IAAI,MAAoC,CAAA;QACxC,MAAM,YAAY,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAA;QAClE,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC5C,IAAI,QAAQ,EAAE,CAAC;YACd,MAAM,GAAG;gBACR,MAAM,EAAE,YAAY;gBACpB,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC;aAC9D,CAAA;QACF,CAAC;QACD,OAAO,MAAM,CAAA;IACd,CAAC;IAlBe,WAAQ,WAkBvB,CAAA;AACF,CAAC,EArBgB,EAAE,kBAAF,EAAE,QAqBlB"}

package/dist/cjs/Account/Creatable.d.ts

@@ -5,7 +5,7 @@ export interface Creatable {
     location?: Creatable.Location;
 }
 export declare namespace Creatable {
-    type Location = typeof Location.values[number];
+    type Location = (typeof Location.values)[number];
     namespace Location {
         const values: readonly ["north-east-america", "west-europe"];
         function toCloudflare(value: Location): DurableObjectLocationHint;

package/dist/cjs/Account/History.d.ts

@@ -6,7 +6,7 @@ export type History = {
     to?: any;
 };
 export declare namespace History {
-    type Property = typeof Property.values[number];
+    type Property = (typeof Property.values)[number];
     namespace Property {
         const values: readonly ["status", "rails", "counterparts", "rules", "created", "updated", "buffer", "listeners"];
         const type: isly.Type<"buffer" | "created" | "status" | "rules" | "rails" | "counterparts" | "updated" | "listeners">;

package/dist/cjs/Account/Status.d.ts

@@ -3,11 +3,11 @@ export type Status = {
     reason?: Status.Reason;
 };
 export declare namespace Status {
-    type Mode = typeof Mode.values[number] | (string & Record<never, never>);
+    type Mode = (typeof Mode.values)[number] | (string & Record<never, never>);
     namespace Mode {
         const values: readonly ["active", "frozen", "closed"];
     }
-    type Reason = typeof Reason.values[number] | (string & Record<never, never>);
+    type Reason = (typeof Reason.values)[number] | (string & Record<never, never>);
     namespace Reason {
         const values: readonly ["overdraft", "other"];
     }

package/dist/cjs/Account/Type.d.ts

@@ -1,5 +1,5 @@
 import { isly } from "isly";
-export type Type = typeof Type.values[number];
+export type Type = (typeof Type.values)[number];
 export declare namespace Type {
     const values: readonly ["own funds", "emoney"];
     const type: isly.Type<"own funds" | "emoney">;

package/dist/cjs/Audit.d.ts

@@ -3,7 +3,7 @@ import { isly } from "isly";
 export type Audit = storage.AuditLogger.Entry<Audit.Type>;
 export declare namespace Audit {
     type Type = {
-        [K in keyof typeof Resource.value]: typeof Resource.value[K][number];
+        [K in keyof typeof Resource.value]: (typeof Resource.value)[K][number];
     };
     type Resource = keyof typeof Resource.value;
     namespace Resource {

package/dist/cjs/Authorization/Status.d.ts

@@ -4,7 +4,7 @@ import { Transaction } from "../Transaction";
 export type Status = "approved" | Status.Failed;
 export declare namespace Status {
     const failures: readonly ["insufficient funds", "cancelled card", "card expired", "exceeds limit", "invalid csc", "system failure", "invalid request", "expired", "denied", "merchant lock violation", "card not found", "account not found", "other"];
-    type Failed = typeof failures[number];
+    type Failed = (typeof failures)[number];
     namespace Failed {
         function from(error: gracely.Error | Transaction.Status.Reason): Failed;
     }