@pax2pay/model-banking 0.1.471 → 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/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/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/Statistics.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { typedly } from "typedly"
 import { Card } from "../Card"
 import { Transaction } from "."
 
@@ -77,11 +78,13 @@ export namespace Statistics {
 	}
 	export function combine(accumulation: Statistics, incoming: Statistics, currency: isoly.Currency): Statistics {
 		const [statistics, cards] = (({ cursor, cards, ...rest }) => [rest, cards])(incoming)
-		Object.entries(statistics).forEach(([kind, statistic]: [TransactionType, Statistics[TransactionType]]) =>
-			Object.entries(statistic).forEach(([region, { count, amount }]: [Region, { count: number; amount: number }]) => {
-				accumulation[kind][region].count += count
-				accumulation[kind][region].amount = isoly.Currency.add(currency, accumulation[kind][region].amount, amount)
-			})
+		typedly.Object.entries(statistics).forEach(([kind, statistic]: [TransactionType, Statistics[TransactionType]]) =>
+			typedly.Object.entries(statistic).forEach(
+				([region, { count, amount }]: [Region, { count: number; amount: number }]) => {
+					accumulation[kind][region].count += count
+					accumulation[kind][region].amount = isoly.Currency.add(currency, accumulation[kind][region].amount, amount)
+				}
+			)
 		)
 		cards.forEach(card => accumulation.cards.includes(card) || accumulation.cards.push(card))
 		return accumulation

package/Warning/Settlement/NegativeAmount.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { typedly } from "typedly"
 import { Identifier } from "../../Settlement/Identifier"
-import { Total } from "../../Settlement/Total"
 import { Totals } from "../../Settlement/Totals"
 import { Base } from "../Base"
 
@@ -21,8 +21,9 @@ export namespace NegativeAmount {
 	})
 	export function create(resource: Identifier, totals: Totals): NegativeAmount[] {
 		const warnings: NegativeAmount[] = []
-		Object.entries(totals).forEach(
-			([currency, total]: [isoly.Currency, Total]) =>
+		typedly.Object.entries(totals).forEach(
+			([currency, total]) =>
+				total &&
 				(total.outcome?.net ?? 0) < 0 &&
 				warnings.push({
 					type: "negative-amount",

package/dist/cjs/Account/Creatable.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Creatable = void 0;
+const isly_1 = require("isly");
+var Creatable;
+(function (Creatable) {
+    let Location;
+    (function (Location) {
+        Location.values = ["north-east-america", "west-europe"];
+        function toCloudflare(value) {
+            return value == "north-east-america" ? "enam" : "weur";
+        }
+        Location.toCloudflare = toCloudflare;
+        Location.type = isly_1.isly.string(Location.values);
+    })(Location = Creatable.Location || (Creatable.Location = {}));
+    Creatable.type = isly_1.isly.object({ name: isly_1.isly.string(), location: Location.type.optional() });
+})(Creatable || (exports.Creatable = Creatable = {}));
+//# sourceMappingURL=Creatable.js.map

package/dist/cjs/Account/Creatable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Creatable.js","sourceRoot":"","sources":["../../../Account/Creatable.ts"],"names":[],"mappings":";;;AACA,+BAA2B;AAO3B,IAAiB,SAAS,CAWzB;AAXD,WAAiB,SAAS;IAEzB,IAAiB,QAAQ,CAOxB;IAPD,WAAiB,QAAQ;QACX,eAAM,GAAG,CAAC,oBAAoB,EAAE,aAAa,CAAU,CAAA;QACpE,SAAgB,YAAY,CAAC,KAAe;YAC3C,OAAO,KAAK,IAAI,oBAAoB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAA;QACvD,CAAC;QAFe,qBAAY,eAE3B,CAAA;QAEY,aAAI,GAAG,WAAI,CAAC,MAAM,CAAC,SAAA,MAAM,CAAC,CAAA;IACxC,CAAC,EAPgB,QAAQ,GAAR,kBAAQ,KAAR,kBAAQ,QAOxB;IACY,cAAI,GAAG,WAAI,CAAC,MAAM,CAAY,EAAE,IAAI,EAAE,WAAI,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAA;AACxG,CAAC,EAXgB,SAAS,yBAAT,SAAS,QAWzB"}