@pax2pay/model-banking 0.1.601 → 0.1.603

package/.eslintrc

@@ -3,20 +3,27 @@
 	"parser": "@typescript-eslint/parser",
 	"plugins": [
 		"@typescript-eslint",
-		"prettierx",
+		"prettier",
 		"simple-import-sort"
 	],
 	"extends": [
 		"eslint:recommended",
 		"plugin:@typescript-eslint/eslint-recommended",
 		"plugin:@typescript-eslint/recommended",
-		"plugin:prettierx/default"
+		"plugin:prettier/recommended"
 	],
 	"rules": {
-		"prettierx/options": [
-			1,
+		"curly": [
+			"error",
+			"all"
+		],
+		"prettier/prettier": [
+			"warn",
 			{
-				"singleQuote": false
+				"semi": false,
+				"singleQuote": false,
+				"tabWidth": 2,
+				"trailingComma": "es5"
 			}
 		],
 		"@typescript-eslint/no-explicit-any": "off",
@@ -41,10 +48,6 @@
 		"no-case-declarations": "off",
 		"no-inner-declarations": "off",
 		"sort-imports": "off",
-		"curly": [
-			"warn",
-			"multi"
-		],
 		"simple-import-sort/imports": [
 			"error",
 			{
@@ -74,9 +77,5 @@
 			}
 		]
 	},
-	"settings": {
-		"prettierx": {
-			"usePrettierrc": true
-		}
-	}
+	"settings": {}
 }

package/.prettierrc

@@ -4,8 +4,7 @@
 	"semi": false,
 	"singleQuote": false,
 	"bracketSpacing": true,
-	"jsxBracketSameLine": true,
+	"bracketSameLine": true,
 	"arrowParens": "avoid",
-	"endOfLine": "lf",
-	"breakBeforeStatement": "always"
+	"endOfLine": "lf"
 }

package/Account/Charge/Fx/index.ts

@@ -18,12 +18,13 @@ export namespace Fx {
 		let result: Amount.Charge.Fx | undefined
 		const chargePreset = preset && charge[preset] ? preset : "default"
 		const chargeRate = charge[chargePreset] ?? 0
-		if (exchange)
+		if (exchange) {
 			result = {
 				preset: chargePreset,
 				rate: chargeRate,
 				amount: -isoly.Currency.multiply(currency, amount, chargeRate),
 			}
+		}
 		return result
 	}
 }

package/Account/Creatable.ts

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

package/Account/History.ts

@@ -8,7 +8,7 @@ export type History = {
 }
 
 export namespace History {
-	export type Property = typeof Property.values[number]
+	export type Property = (typeof Property.values)[number]
 	export namespace Property {
 		export const values = [
 			"status",

package/Account/Status.ts

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

package/Account/Type.ts

@@ -1,6 +1,6 @@
 import { isly } from "isly"
 
-export type Type = typeof Type.values[number]
+export type Type = (typeof Type.values)[number]
 export namespace Type {
 	export const values = ["own funds", "emoney"] as const
 	export const type = isly.string<Type>(values)

package/Audit.ts

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

package/Authorization/Status.ts

@@ -6,19 +6,21 @@ export type Status = "approved" | Status.Failed
 
 export namespace Status {
 	export const failures = [...Transaction.Status.reasons, "card not found", "account not found", "other"] as const
-	export type Failed = typeof failures[number]
+	export type Failed = (typeof failures)[number]
 	export namespace Failed {
 		export function from(error: gracely.Error | Transaction.Status.Reason): Failed {
 			let result: Status
-			if (gracely.Error.is(error))
-				if (error.error?.includes("Card with id"))
+			if (gracely.Error.is(error)) {
+				if (error.error?.includes("Card with id")) {
 					result = "card not found"
-				else if (error.error?.includes("Failed to reach account"))
+				} else if (error.error?.includes("Failed to reach account")) {
 					result = "account not found"
-				else
+				} else {
 					result = "other"
-			else
+				}
+			} else {
 				result = error
+			}
 			return result
 		}
 	}

package/Backup/Base.ts

@@ -14,7 +14,7 @@ export type Base<T> = {
 	value: T
 }
 export namespace Base {
-	export type Action = typeof Action.values[number]
+	export type Action = (typeof Action.values)[number]
 	export namespace Action {
 		export const values = ["created", "updated", "cancelled", "removed", "inactivated"] as const
 	}

package/Balance.ts

@@ -4,7 +4,7 @@ import { Amount } from "./Amount"
 
 export type Balance = { available?: number; reserved?: Balance.Reserved }
 export namespace Balance {
-	export type Reserve = typeof Reserve.values[number]
+	export type Reserve = (typeof Reserve.values)[number]
 	export namespace Reserve {
 		export const values = ["incoming", "outgoing", "buffer"] as const
 		export const type = isly.string<Reserve>(values)
@@ -16,7 +16,7 @@ export namespace Balance {
 	})
 	export type Legacy = Partial<Record<Legacy.Entry, number>>
 	export namespace Legacy {
-		export type Entry = typeof Entry.values[number]
+		export type Entry = (typeof Entry.values)[number]
 		export namespace Entry {
 			export const values = ["actual", "incomingReserved", "outgoingReserved", "bufferReserved"] as const
 			export const type = isly.string<Entry>(values)

package/Balances.ts

@@ -10,20 +10,23 @@ export namespace Balances {
 	export const type = isly.record<Balances>(isly.fromIs("isoly.Currency", isoly.Currency.is), Balances.Balance.type)
 	export function update(balances: Balances): Balances {
 		const result: Balances = {}
-		for (const [currency, balance] of Object.entries(balances))
+		for (const [currency, balance] of Object.entries(balances)) {
 			result[currency as isoly.Currency] = Balance.update(currency as isoly.Currency, balance)
+		}
 		return result
 	}
 	export function computeReserved(balances: Balances): Amounts {
 		const result: Amounts = {}
-		for (const [currency, balance] of Object.entries(balances))
+		for (const [currency, balance] of Object.entries(balances)) {
 			result[currency as isoly.Currency] = Balance.computeReserved(currency as isoly.Currency, balance)[1]
+		}
 		return result
 	}
 	export function computeActual(balances: Balances): Amounts {
 		const result: Amounts = {}
-		for (const [currency, balance] of Object.entries(balances))
+		for (const [currency, balance] of Object.entries(balances)) {
 			result[currency as isoly.Currency] = Balance.computeActual(currency as isoly.Currency, balance)[1]
+		}
 		return result
 	}
 }

package/Card/Expiry.ts

@@ -3,10 +3,10 @@ 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]
+type Year = (typeof year)[number]
 
 const month = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] as const
-type Month = typeof month[number]
+type Month = (typeof month)[number]
 
 export type Expiry = [Year, Month]
 export namespace Expiry {

package/Card/Operation/Authorization.ts

@@ -12,7 +12,7 @@ export interface Authorization {
 
 export namespace Authorization {
 	export const statuses = ["created", "confirmed", "refunded", "captured", "cancelled"] as const
-	export type Status = typeof statuses[number]
+	export type Status = (typeof statuses)[number]
 	export const type = isly.object<Authorization>({
 		type: isly.string("authorization"),
 		id: isly.string(),

package/Card/Operation/Card.ts

@@ -13,7 +13,7 @@ export interface Card {
 
 export namespace Card {
 	export const statuses = ["created", "changed", "cancelled"] as const
-	export type Status = typeof statuses[number]
+	export type Status = (typeof statuses)[number]
 	export const type = isly.object<Card>({
 		type: isly.string("card"),
 		status: isly.string(statuses),

package/Card/Operation/index.ts

@@ -25,7 +25,7 @@ export namespace Operation {
 					id: entry.transaction.id,
 					status: entry.type == "capture" ? "captured" : "refunded",
 					created: isoly.DateTime.now(),
-			  }
+				}
 	}
 	export const type = isly.union(Card.type, OperationAuthorization.type)
 	export const type2: isly2.Union<Operation> = isly2

package/Card/Preset.ts

@@ -3,7 +3,7 @@ import { isly as isly2 } from "isly2"
 import { Realm } from "../Realm"
 import { Stack } from "./Stack"
 
-export type Preset = typeof Preset.names[number]
+export type Preset = (typeof Preset.names)[number]
 
 // (test OR p2p)-scheme-interchange
 export namespace Preset {

package/Card/Restriction/Merchant.ts

@@ -5,7 +5,7 @@ import { Rail } from "../../Rail"
 import { merchants } from "./merchants"
 import { Merchant as Attribute } from "./merchants/Merchant"
 
-export type Merchant = typeof Merchant.values[number]
+export type Merchant = (typeof Merchant.values)[number]
 export namespace Merchant {
 	export const values = typedly.Object.keys(merchants)
 	export const type = isly.string<Merchant>(values)
@@ -13,27 +13,29 @@ export namespace Merchant {
 	export function check(merchant: Merchant, counterpart: Rail.Address.Card.Counterpart): boolean {
 		const attribute: Attribute = merchants[merchant]
 		let result: boolean
-		if (attribute?.unambiguousMcc == counterpart.merchant.category)
+		if (attribute?.unambiguousMcc == counterpart.merchant.category) {
 			result = true
-		else if (attribute.contains && attribute.mccs)
+		} else if (attribute.contains && attribute.mccs) {
 			result =
 				attribute.mccs.some(mcc => mcc == counterpart.merchant.category) &&
 				attribute.contains.some(n => counterpart.merchant.name.includes(n))
-		else if (attribute.startsWith && attribute.mccs)
+		} else if (attribute.startsWith && attribute.mccs) {
 			result =
 				attribute.mccs.some(mcc => mcc == counterpart.merchant.category) &&
 				attribute.startsWith.some(n => counterpart.merchant.name.startsWith(n))
-		else
+		} else {
 			result = false
+		}
 		return result
 	}
 	export function resolve(counterpart: Rail.Address.Card.Counterpart): Merchant | undefined {
 		let result: Merchant | undefined
-		for (const merchant of values)
+		for (const merchant of values) {
 			if (check(merchant, counterpart)) {
 				result = merchant
 				break
 			}
+		}
 		return result
 	}
 }

package/Card/Restriction/index.ts

@@ -21,8 +21,9 @@ export namespace Restriction {
 		transaction: Transaction.Creatable.CardTransaction | Transaction.PreTransaction.Authorization
 	): boolean {
 		let result: boolean = true
-		if (restrictions.merchants?.length)
+		if (restrictions.merchants?.length) {
 			result = restrictions.merchants.some(merchant => Merchant.check(merchant, transaction.counterpart))
+		}
 		return result
 	}
 }

package/Card/Scheme.ts

@@ -1,7 +1,7 @@
 import { isly } from "isly"
 import { isly as isly2 } from "isly2"
 
-export type Scheme = typeof Scheme.schemes[number]
+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)

package/Card/Stack.ts

@@ -1,7 +1,7 @@
 import { isly } from "isly"
 import { Realm } from "../Realm"
 
-export type Stack = typeof Stack.stacks[number]
+export type Stack = (typeof Stack.stacks)[number]
 
 // realm-scheme-processor(-processor...)
 export namespace Stack {
@@ -88,5 +88,5 @@ export namespace Stack {
 			)?.[0]
 		}
 	}
-	export type Character = typeof Character.values[number]
+	export type Character = (typeof Character.values)[number]
 }

package/Client/Labels.ts

@@ -3,7 +3,10 @@ import { http } from "cloudly-http"
 import { Label } from "../Label"
 
 export class Labels {
-	constructor(private readonly client: http.Client, readonly type: Label.Type) {}
+	constructor(
+		private readonly client: http.Client,
+		readonly type: Label.Type
+	) {}
 	async create(label: Label): Promise<Label | gracely.Error> {
 		return this.client.post<Label>(`/label/${this.type}`, label)
 	}

package/Client/Operations.ts

@@ -15,10 +15,10 @@ export class Operations {
 			options?.start && options?.end
 				? `?start=${options?.start}&end=${options?.end}`
 				: options?.start
-				? `?start=${options?.start}`
-				: options?.end
-				? `?end=${options?.end}`
-				: ""
+					? `?start=${options?.start}`
+					: options?.end
+						? `?end=${options?.end}`
+						: ""
 		return this.client.get<Operation[] & { cursor?: string | undefined }>(
 			`/operation${search}`,
 			options && (({ start, end, ...headers }) => headers)(options)

package/Client/Transactions/index.ts

@@ -71,8 +71,9 @@ export namespace Transactions {
 			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
+			if (typeof query == "string") {
+				query = query ? http.Search.parse(query.replace("?", "")) : {}
+			} // search.parse does not support empty string
 			return type.prune(query) ?? {}
 		}
 	}

package/Client/index.ts

@@ -79,19 +79,20 @@ export class Client {
 			appendHeader: request => ({
 				...request.header,
 				realm: result.realm,
-				...(request.header.organization ?? result.organization
+				...((request.header.organization ?? result.organization)
 					? { organization: request.header.organization ?? result.organization }
 					: {}),
 			}),
 			postprocess: async response => {
 				let result = response
 				const body = await response.body
-				if (Array.isArray(body))
+				if (Array.isArray(body)) {
 					result = http.Response.create(
 						Object.defineProperty(body, "cursor", {
 							value: response.header.cursor ?? response.header.link?.split?.(",")[0],
 						})
 					)
+				}
 				return result
 			},
 		})

package/Holidays/index.ts

@@ -3,7 +3,7 @@ import { isly } from "isly"
 import { Dates } from "./Dates"
 
 export namespace Holidays {
-	export type Regions = typeof Regions.values[number]
+	export type Regions = (typeof Regions.values)[number]
 	export namespace Regions {
 		export const values = ["England", "Wales", "Scotland", "Northern Ireland"] as const
 		export const type = isly.string<Regions>(values)

package/Label.ts

@@ -7,7 +7,7 @@ export interface Label {
 }
 export namespace Label {
 	export const type = isly.object<Label>({ name: isly.string(), color: isly.string(), description: isly.string() })
-	export type Type = typeof Type.values[number]
+	export type Type = (typeof Type.values)[number]
 	export namespace Type {
 		export const values = ["flag", "group"] as const
 		export const type = isly.string(values)

package/Log/Message/Configuration.ts

@@ -16,7 +16,7 @@ export namespace Configuration {
 					collection: trace.message[0].collection,
 					resource: trace.message[0].resource,
 					requireEntries: trace.message[0].requireEntries,
-			  }
+				}
 			: undefined
 	}
 }

package/Log/Message/Entry.ts

@@ -16,7 +16,7 @@ export namespace Entry {
 						data: trace.message[0].data,
 					},
 					resource: trace.message[0].resource,
-			  }
+				}
 			: undefined
 	}
 }

package/Log/Message/index.ts

@@ -19,15 +19,16 @@ export namespace Message {
 					realm: configuration.realm,
 					resource: configuration.resource,
 					entries: [],
-			  }
+				}
 			: undefined
-		if (result)
+		if (result) {
 			for (const trace of traces) {
 				const logFragment: { entry: Log.Entry; resource: Log["resource"] } | undefined =
 					Message.Entry.fromEventLogs(trace)
 				logFragment?.resource && (result.resource ??= logFragment.resource)
 				logFragment?.entry && result.entries.push(logFragment.entry)
 			}
+		}
 		return (configuration?.requireEntries && result?.entries && result.entries.length > 0) ||
 			!configuration?.requireEntries
 			? result

package/Log/index.ts

@@ -50,10 +50,12 @@ export namespace Log {
 		locations?: LogLocations
 	): void {
 		const configuration = { collection, realm, resource, requireEntries }
-		if (Log.Message.Configuration.type.safeParse(configuration).success)
+		if (Log.Message.Configuration.type.safeParse(configuration).success) {
 			console.log(configuration)
-		if (Log.Locations.type.safeParse(locations).success)
+		}
+		if (Log.Locations.type.safeParse(locations).success) {
 			console.log(Log.Entry.Message.to("Locations", locations, resource))
+		}
 	}
 	export function log(message: string, data?: any, resource?: string): void {
 		console.log(Log.Entry.Message.to(message, data, resource))

package/Operation/Change.ts

@@ -10,7 +10,7 @@ export interface Change<T extends Change.Operand = Change.Operand> {
 
 export namespace Change {
 	export const operand = ["add", "subtract"] as const
-	export type Operand = typeof operand[number]
+	export type Operand = (typeof operand)[number]
 	export const type = isly.object<Change>({
 		type: isly.string(["add", "subtract"]),
 		amount: isly.number(),

package/Operation/Changes.ts

@@ -18,10 +18,10 @@ export namespace Changes {
 								: 0
 						),
 					0
-			  )
+				)
 			: "available" in changes
-			? (changes.available?.type == "subtract" ? -1 : 1) * (changes.available?.amount ?? 0)
-			: 0
+				? (changes.available?.type == "subtract" ? -1 : 1) * (changes.available?.amount ?? 0)
+				: 0
 	}
 	export function reserved(changes: MaybeLegacy, currency: isoly.Currency): number {
 		return Object.entries(changes).reduce(
@@ -57,7 +57,7 @@ export namespace Changes {
 		export const type = isly.record<Legacy>(isly.string(), Change.type)
 		export type Entry = AccountBalance.Legacy.Entry
 		export namespace Entry {
-			export type Balance = typeof AccountBalance.Legacy.Entry.values[number]
+			export type Balance = (typeof AccountBalance.Legacy.Entry.values)[number]
 			export namespace Balance {
 				export const type = AccountBalance.Legacy.Entry.type
 			}
@@ -68,17 +68,18 @@ export namespace Changes {
 		export const type = isly.string<Entry>()
 		export function getBalanceType(key: string): string {
 			let result = ""
-			if (key.includes("net") || key.includes("fee") || key.includes("charge"))
+			if (key.includes("net") || key.includes("fee") || key.includes("charge")) {
 				result = "collecting"
-			else if (key.toLowerCase().includes("reserved") || key === "available")
+			} else if (key.toLowerCase().includes("reserved") || key === "available") {
 				result = "balance"
-			else if (key.includes("internal"))
+			} else if (key.includes("internal")) {
 				result = "equalizing"
-			else
+			} else {
 				result = "fiat"
+			}
 			return result
 		}
-		export type Balance = typeof Balance.values[number]
+		export type Balance = (typeof Balance.values)[number]
 		export namespace Balance {
 			export const values = ["available", "reserved-incoming", "reserved-outgoing", "reserved-buffer"] as const
 			export const type = isly.string<Balance>(values)

package/Operation/Creatable.ts

@@ -29,7 +29,7 @@ export namespace Creatable {
 		"legacy",
 		"adjustBuffer",
 	] as const
-	export type Type = typeof types[number]
+	export type Type = (typeof types)[number]
 	export const type = isly.object<Creatable>({
 		account: isly.fromIs("cryptly.Identifier", cryptly.Identifier.is),
 		currency: isly.fromIs("isoly.Currency", isoly.Currency.is),

package/Operation/Status.ts

@@ -1,6 +1,6 @@
 import { isly } from "isly"
 
-export type Status = typeof Status.values[number]
+export type Status = (typeof Status.values)[number]
 
 export namespace Status {
 	export const values = ["pending", "success", "failed"] as const

package/Operation/index.ts

@@ -19,7 +19,7 @@ export namespace Operation {
 	}
 	export function sum(operations: Operation[]): Changes.Sum {
 		const result: Changes.Sum = {}
-		for (const operation of operations)
+		for (const operation of operations) {
 			Object.entries(operation.changes).forEach(([entry, change]) => {
 				result[entry as Changes.Entry.Balance] = isoly.Currency[change.type](
 					operation.currency,
@@ -27,6 +27,7 @@ export namespace Operation {
 					change.amount
 				)
 			})
+		}
 		return result
 	}
 	export import Signer = OperationSigner

package/Organization/Risk.ts

@@ -1,6 +1,6 @@
 import { isly } from "isly"
 
-export type Risk = typeof Risk.values[number]
+export type Risk = (typeof Risk.values)[number]
 
 export namespace Risk {
 	export const values = ["low", "medium", "high", "prohibited"] as const

package/Quarter.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 
-export type Quarter = typeof Quarter.values[number]
+export type Quarter = (typeof Quarter.values)[number]
 export namespace Quarter {
 	export const values = ["Q1", "Q2", "Q3", "Q4"] as const
 	export const type = isly.string<Quarter>(values)

package/Rail/Address/Route.ts

@@ -6,11 +6,11 @@ export namespace Route {
 	export namespace Account {
 		export const type = isly.object<Account>({ type: isly.string("account"), id: isly.string() })
 	}
-	export type Service = { type: "service"; service: "paxgiroCredit"; configuration: string }
+	export type Service = { type: "service"; service: string; configuration: string }
 	export namespace Service {
 		export const type = isly.object<Service>({
 			type: isly.string("service"),
-			service: isly.string("paxgiroCredit"),
+			service: isly.string(),
 			configuration: isly.string(),
 		})
 	}