@pax2pay/model-banking 0.1.470 → 0.1.472

package/Amount.ts

@@ -1,5 +1,7 @@
 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]
@@ -8,5 +10,9 @@ export namespace Amount {
 	export function toAmounts(amount?: Amount): Amounts {
 		return !amount ? {} : Object.fromEntries<number>([amount])
 	}
-	export const type = isly.tuple<Amount>(isly.string(isoly.Currency.types), isly.number())
+	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/Amounts.ts

@@ -18,5 +18,5 @@ export namespace Amounts {
 			currency => left[currency] == right[currency]
 		)
 	}
-	export const type = isly.record<Amounts>(isly.string(isoly.Currency.types), isly.number())
+	export const type = isly.record<Amounts>(isly.string(isoly.Currency.values), isly.number())
 }

package/Analytics/Configuration/Transaction.ts

@@ -5,7 +5,7 @@ import { Base } from "./Base"
 
 export namespace Transaction {
 	type Selectors = Base.Selectors | `value.${FlattenKeys<Required<ModelTransaction>>}${"[*]" | ""}`
-	export const mapping = {
+	export const mapping: filter.Mapping.RecordWithSelector<Selectors> = {
 		...Base.mapping,
 		counterpartType: "value.counterpart.type",
 		counterpart: { selector: "value.counterpart", transform: "stringify" },
@@ -32,34 +32,37 @@ export namespace Transaction {
 		actualBalance: { selector: "value.balance.actual", transform: "string" },
 		reservedBalance: { selector: "value.balance.reserved", transform: "string" },
 		availableBalance: { selector: "value.balance.available", transform: "string" },
-		operations: { selector: "value.operations[*]", transform: {
-			account: "account",
-			currency: "currency",
-			changes: { 
-				selector: "changes", 
-				transform: [
-					"array",
-					{
-						key: "key",
-						value: {
-							selector: "value",
-							transform: {
-								type: "type",
-								amount: { selector: "amount", transform: "string" },
-								status: "status",
-								result: { selector: "result", transform: "string" }
-							}
-						}
-					}
-				]
+		operations: {
+			selector: "value.operations[*]",
+			transform: {
+				account: "account",
+				currency: "currency",
+				changes: {
+					selector: "changes",
+					transform: [
+						"array",
+						{
+							key: "key",
+							value: {
+								selector: "value",
+								transform: {
+									type: "type",
+									amount: { selector: "amount", transform: "string" },
+									status: "status",
+									result: { selector: "result", transform: "string" },
+								},
+							},
+						},
+					],
+				},
+				type: "type",
+				transaction: "transaction",
+				counter: { selector: "counter", transform: "string" },
+				created: "created",
+				signature: "signature",
+				previous: "previous",
 			},
-			type: "type",
-			transaction: "transaction",
-			counter: { selector: "counter", transform: "string" },
-			created: "created",
-			signature: "signature",
-			previous: "previous",
-		}},
+		},
 		status: "value.status",
 		rail: "value.rail",
 		flags: "value.flags",
@@ -67,8 +70,7 @@ export namespace Transaction {
 		notes: { selector: "value.notes", transform: "stringify" },
 		risk: { selector: "value.risk", transform: "string" },
 		state: { selector: "value.state", transform: "stringify" },
-		// eslint-disable-next-line
-	} as const satisfies filter.Mapping.RecordWithSelector<Selectors>;
+	}
 	export type Fields = keyof typeof mapping
 	export const schema: listener.BigQueryApi.BaseField<Fields>[] = [
 		...Base.schema,
@@ -97,25 +99,38 @@ export namespace Transaction {
 		{ name: "actualBalance", type: "NUMERIC" },
 		{ name: "reservedBalance", type: "NUMERIC" },
 		{ name: "availableBalance", type: "NUMERIC" },
-		{ name: "operations", type: "RECORD", mode: "REPEATED", fields: [
+		{
+			name: "operations",
+			type: "RECORD",
+			mode: "REPEATED",
+			fields: [
 				{ name: "account", type: "STRING" },
 				{ name: "currency", type: "STRING" },
-				{ name: "changes", type: "RECORD", mode: "REPEATED", fields: [
-					{ name: "key", type: "STRING" },
-					{ name: "value", type: "RECORD", fields: [
-						{ name: "type", type: "STRING" },
-						{ name: "amount", type: "NUMERIC" },
-						{ name: "status", type: "STRING" },
-						{ name: "result", type: "NUMERIC", mode: "NULLABLE" },
-					]}
-				] },
+				{
+					name: "changes",
+					type: "RECORD",
+					mode: "REPEATED",
+					fields: [
+						{ name: "key", type: "STRING" },
+						{
+							name: "value",
+							type: "RECORD",
+							fields: [
+								{ name: "type", type: "STRING" },
+								{ name: "amount", type: "NUMERIC" },
+								{ name: "status", type: "STRING" },
+								{ name: "result", type: "NUMERIC", mode: "NULLABLE" },
+							],
+						},
+					],
+				},
 				{ name: "type", type: "STRING" },
 				{ name: "transaction", type: "STRING" },
 				{ name: "counter", type: "NUMERIC" },
 				{ name: "created", type: "TIMESTAMP" },
 				{ name: "signature", type: "STRING" },
 				{ name: "previous", type: "STRING" },
-			]
+			],
 		},
 		{ name: "status", type: "STRING" },
 		{ name: "rail", type: "STRING", mode: "NULLABLE" },

package/Card/Changeable.ts

@@ -1,5 +1,7 @@
 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"
 
@@ -13,4 +15,15 @@ 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,5 +1,7 @@
 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"
@@ -35,4 +37,27 @@ export namespace Creatable {
 		meta: isly.fromIs("Card.Meta", Meta.is).optional(),
 		key: isly.string().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()
+			.rename("Rules")
+			.describe("Card rules that applies to authorizations made with the card."),
+		meta: isly2.from("Meta", Meta.is).optional(),
+		key: isly2.string().optional(),
+	})
 }

package/Card/Expiry.ts

@@ -1,5 +1,6 @@
 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]
@@ -10,6 +11,19 @@ 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,5 +1,7 @@
 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
@@ -18,4 +20,14 @@ 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,5 +1,7 @@
 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 {
@@ -18,4 +20,16 @@ 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,5 +1,6 @@
 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"
@@ -27,4 +28,8 @@ 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,4 +1,5 @@
 import { isly } from "isly"
+import { isly as isly2 } from "isly2"
 import { Stack } from "./Stack"
 
 export type Preset = typeof Preset.names[number]
@@ -15,6 +16,10 @@ export namespace Preset {
 		"p2p-diners-200",
 	] 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 presets: Record<Preset, Stack> = {
 		"p2p-mc-200": "uk-mc-tpl-marqeta",
 		"p2p-diners-175": "uk-diners-dpg",

package/Card/Scheme.ts

@@ -1,7 +1,12 @@
 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,5 +1,6 @@
 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"
@@ -63,6 +64,37 @@ export namespace Card {
 		rules: ruleType.array(),
 		meta: isly.fromIs("Card.Meta", CardMeta.is).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().optional().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."),
+		})
+		.rename("Card")
+		.describe("Card information.")
 	export import Creatable = CardCreatable
 	export import Preset = CardPreset
 	export import Meta = CardMeta

package/Rail/Address/index.ts

@@ -25,9 +25,7 @@ export namespace Address {
 	export const values = ["paxgiro", "internal", "iban", "scan", "card", "paxgiro-credit"] as const
 	export type Type = typeof values[number]
 	export function compare(addresses: [Address, Address]): boolean {
-		return Object.entries(addresses[0]).every(
-			([key, value]: [keyof Address, Address[keyof Address]]) => value == addresses[1][key]
-		)
+		return Object.entries(addresses[0]).every(([key, value]) => value == (addresses[1] as any)[key])
 	}
 	export function parse(value: string): Address | undefined {
 		let result: Address | undefined

package/Realm.ts

@@ -1,12 +1,17 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { isly as isly2 } from "isly2"
 import { Supplier as modelSupplier } from "./Supplier"
 
 export type Realm = typeof Realm.realms[number]
 
 export namespace Realm {
 	export const realms = ["test", "uk", "eea"] as const
-	export const type: isly.Type<Realm> = isly.string(realms)
+	export const type = isly.string<Realm>(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,4 +1,5 @@
 import { isly } from "isly"
+import { isly as isly2 } from "isly2"
 import { Preset } from "../Card/Preset"
 
 export interface Base {
@@ -17,6 +18,10 @@ 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))
@@ -28,6 +33,10 @@ 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\-_]+$/),
@@ -40,4 +49,21 @@ 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,7 @@
 import { isoly } from "isoly"
 import { selectively } from "selectively"
 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,8 +15,13 @@ 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/Score.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { selectively } from "selectively"
 import { isly } from "isly"
+import { isly as isly2 } from "isly2"
 import type { Note } from "../Transaction/Note"
 import { Base } from "./Base"
 import { control } from "./control"
@@ -23,6 +24,19 @@ export namespace Score {
 		category: isly.string("fincrime"),
 		risk: Risk,
 	})
+	export const type2: isly2.Object<Score> = Base.type2.extend<Score>({
+		action: isly2
+			.string("value", Action.value)
+			.rename("Action")
+			.describe("The action to take when the rule is applied."),
+		category: isly2.string("value", "fincrime").rename("Category").describe("The category of the rule."),
+		risk: isly2
+			.number<Risk>()
+			.restrict("integer")
+			.restrict("positive")
+			.rename("Risk")
+			.describe("The risk of the rule."),
+	})
 	export function evaluate(
 		rules: Score[],
 		state: State,

package/Rule/State/Account.ts

@@ -1,6 +1,8 @@
 import type { Account as ModelAccount } from "../../Account"
+import { Rail } from "../../Rail"
 
 export interface Account extends ModelAccount {
+	address: Rail.Address
 	transactions: Account.Transactions
 	days: Account.Days
 }
@@ -24,7 +26,7 @@ export namespace Account {
 		outgoing: { today: Today }
 		card: { today: Today }
 	}
-	export function from(account: ModelAccount, transactions: Transactions, days: Days): Account {
-		return { ...account, transactions, days }
+	export function from(account: ModelAccount, address: Rail.Address, transactions: Transactions, days: Days): Account {
+		return { ...account, address, transactions, days }
 	}
 }

package/Rule/State/Authorization.ts

@@ -40,7 +40,7 @@ export namespace Authorization {
 	export const type = AuthorizationCreatable.type.omit(["amount"]).extend<Authorization>({
 		time: isly.string(),
 		hour: isly.number(),
-		currency: isly.string(isoly.Currency.types),
+		currency: isly.string(isoly.Currency.values),
 		amount: isly.number(),
 		merchant: isly.intersection<Authorization["merchant"], Merchant, { reference: string }>(
 			Merchant.type,

package/Rule/State/Card.ts

@@ -55,7 +55,7 @@ export namespace Card {
 		age: isly.object<Card["age"]>({ days: isly.number(), minutes: isly.number() }),
 		limit: isly.number(),
 		original: isly.object<Card["original"]>({
-			currency: isly.string(isoly.Currency.types),
+			currency: isly.string(isoly.Currency.values),
 			limit: isly.number(),
 		}),
 		used: isly.object<Card["used"]>({ amount: isly.number(), count: isly.number(), merchants: isly.string().array() }),

package/Rule/State/Transaction.ts

@@ -2,7 +2,7 @@ import { isoly } from "isoly"
 import { Transaction as ModelTransaction } from "../../Transaction"
 import type { Rule } from "../index"
 
-export interface Transaction extends ModelTransaction.Creatable {
+export interface Transaction extends ModelTransaction.Creatable.Resolved {
 	kind: Rule.Base.Kind
 	stage: "finalize" | "initiate"
 	amount: number

package/Rule/State/index.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Account as ModelAccount } from "../../Account"
+import { Rail } from "../../Rail"
 import type { Transaction as ModelTransaction } from "../../Transaction"
 import type { Rule } from "../index"
 import { Account as StateAccount } from "./Account"
@@ -40,6 +41,7 @@ export namespace State {
 	export function from(
 		data: Data,
 		account: ModelAccount,
+		address: Rail.Address,
 		transactions: Account.Transactions,
 		days: Account.Days,
 		transaction: ModelTransaction.Creatable.Resolved | ModelTransaction,
@@ -51,7 +53,7 @@ export namespace State {
 	): State {
 		return {
 			data,
-			account: Account.from(account, transactions, days),
+			account: Account.from(account, address, transactions, days),
 			transaction: Transaction.from(account.name, transaction, kind, stage),
 			authorization,
 			card,

package/Rule/type.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+// import { isly as isly2 } from "isly2"
 import { Charge } from "./Charge"
 import type { Rule } from "./index"
 import { Other } from "./Other"
@@ -11,3 +12,7 @@ export const type = isly.union<Rule, Other, Score, Charge.Api, Reserve>(
 	Charge.Api.type,
 	Reserve.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/Settlement/Totals.ts

@@ -5,7 +5,7 @@ import { Total } from "./Total"
 
 export type Totals = Partial<Record<isoly.Currency, Total>>
 export namespace Totals {
-	export const type = isly.record<isoly.Currency, Total>(isly.string(isoly.Currency.types), Total.type)
+	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"))

package/Transaction/Creatable.ts

@@ -1,12 +1,14 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../Rail"
+import { Exchange } from "./Exchange"
 
 export interface Creatable {
 	counterpart: string | Rail.Address
 	currency: isoly.Currency
 	amount: number
 	description: string
+	exchange?: Exchange
 }
 export namespace Creatable {
 	export type Resolved = Creatable & { counterpart: Rail.Address }
@@ -15,5 +17,6 @@ export namespace Creatable {
 		currency: isly.fromIs("isoly.Currency", isoly.Currency.is),
 		amount: isly.number(),
 		description: isly.string(),
+		exchange: Exchange.type.optional(),
 	})
 }