@pax2pay/model-banking 0.1.669 → 0.1.671

package/Account/Details.ts

@@ -2,7 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../Rail"
 import { Supplier } from "../Supplier"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 
 export interface Details {
 	supplier: Supplier
@@ -17,11 +17,11 @@ export namespace Details {
 		reference: isly.string().optional(),
 		addresses: Rail.Address.type.array(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Details> = zod.object({
 		supplier: Supplier.typeZod,
-		currencies: zod.array(zod.enum(isoly.Currency.values)),
+		currencies: zodHelper.currency.array(),
 		reference: zod.string().optional(),
-		addresses: zod.array(Rail.Address.typeZod),
+		addresses: Rail.Address.typeZod.array(),
 	})
 	export interface Creatable {
 		supplier: Supplier
@@ -32,9 +32,9 @@ export namespace Details {
 			supplier: Supplier.type,
 			currency: isly.string(isoly.Currency.values),
 		})
-		export const typeZod = zod.object({
+		export const typeZod: zod.ZodType<Creatable> = zod.object({
 			supplier: Supplier.typeZod,
-			currency: zod.enum(isoly.Currency.values),
+			currency: zodHelper.currency,
 		})
 	}
 }

package/Account/index.ts

@@ -39,7 +39,7 @@ export namespace Account {
 		rails: Rail.Address.type.array(),
 		details: Details.type.optional(),
 		charges: AccountCharge.type.optional(),
-		rules: Rule.type.array().optional(),
+		rules: isly.any().array().optional(),
 		status: AccountStatus.type,
 		type: Type.type,
 	})
@@ -48,10 +48,10 @@ export namespace Account {
 		created: zod.string().refine(isoly.DateTime.is),
 		organization: zod.string(),
 		balances: Balances.typeZod,
-		rails: zod.array(Rail.Address.typeZod),
+		rails: Rail.Address.typeZod.array(),
 		details: Details.typeZod.optional(),
 		charges: AccountCharge.typeZod.optional(),
-		rules: zod.array(zod.never()).optional(),
+		rules: zod.any().array().optional(),
 		status: AccountStatus.typeZod,
 		type: Type.typeZod,
 	})

package/Acquirer/index.ts

@@ -1,6 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 
 export interface Acquirer {
 	id: string
@@ -17,10 +17,10 @@ export namespace Acquirer {
 		retrievalReferenceNumber: isly.string().optional(),
 		systemTraceAuditNumber: isly.string().optional(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Acquirer> = zod.object({
 		id: zod.string(),
 		number: zod.string(),
-		country: zod.string().refine(isoly.CountryCode.Alpha2.is).optional(),
+		country: zodHelper.countryCode.optional(),
 		retrievalReferenceNumber: zod.string().optional(),
 		systemTraceAuditNumber: zod.string().optional(),
 	})

package/Amount.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amounts } from "./Amounts"
-import { zod } from "./zod"
+import { zod, zodHelper } from "./zod"
 
 export type Amount = [isoly.Currency, number]
 
@@ -10,5 +10,5 @@ export namespace Amount {
 		return !amount ? {} : Object.fromEntries<number>([amount])
 	}
 	export const type = isly.tuple<Amount>(isly.string(isoly.Currency.values), isly.number())
-	export const typeZod = zod.tuple([zod.enum(isoly.Currency.values), zod.number()])
+	export const typeZod: zod.ZodType<Amount> = zod.tuple([zodHelper.currency, zod.number()])
 }

package/Amounts.ts

@@ -1,6 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "./zod"
+import { zod, zodHelper } from "./zod"
 
 export type Amounts = Partial<Record<isoly.Currency, number>>
 
@@ -20,5 +20,5 @@ export namespace Amounts {
 		)
 	}
 	export const type = isly.record<Amounts>(isly.string(isoly.Currency.values), isly.number())
-	export const typeZod: zod.ZodType<Amounts> = zod.partialRecord(zod.enum(isoly.Currency.values), zod.number())
+	export const typeZod: zod.ZodType<Amounts> = zod.partialRecord(zodHelper.currency, zod.number())
 }

package/Balances.ts

@@ -2,14 +2,14 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amounts } from "./Amounts"
 import { Balance as BalancesBalance } from "./Balance"
-import { zod } from "./zod"
+import { zod, zodHelper } from "./zod"
 
 export type Balances = Partial<Record<isoly.Currency, Balances.Balance.Extended>>
 
 export namespace Balances {
 	export import Balance = BalancesBalance
 	export const type = isly.record<Balances>(isly.fromIs("isoly.Currency", isoly.Currency.is), Balances.Balance.type)
-	export const typeZod = zod.partialRecord(zod.enum(isoly.Currency.values), Balances.Balance.Extended.typeZod)
+	export const typeZod = zod.partialRecord(zodHelper.currency, Balances.Balance.Extended.typeZod)
 	export function update(balances: Balances): Balances {
 		const result: Balances = {}
 		for (const [currency, balance] of Object.entries(balances)) {

package/Card/Creatable.ts

@@ -1,8 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amount } from "../Amount"
-import type { Rule } from "../Rule"
-import { type as ruleType } from "../Rule/type"
 import { zod } from "../zod"
 import { Expiry } from "./Expiry"
 import { Meta } from "./Meta"
@@ -18,7 +16,6 @@ export interface Creatable {
 		holder: string
 	}
 	limit: Amount
-	rules?: Rule[]
 	meta?: Meta
 	key?: isoly.Date | string
 	restricted?: { to?: Restriction }
@@ -31,18 +28,16 @@ export namespace Creatable {
 		preset: Preset.type,
 		details: isly.object({ expiry: Expiry.type, holder: isly.string() }),
 		limit: isly.tuple(isly.fromIs("isoly.Currency", isoly.Currency.is), isly.number()),
-		rules: ruleType.array().optional(),
 		meta: isly.fromIs("Card.Meta", Meta.is).optional(),
 		key: isly.string().optional(),
 		restricted: isly.object<Required<Creatable>["restricted"]>({ to: Restriction.type.optional() }).optional(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Creatable> = zod.object({
 		account: zod.string(),
 		number: zod.string().optional(),
 		preset: Preset.typeZod,
 		details: zod.object({ expiry: Expiry.typeZod, holder: zod.string() }),
 		limit: Amount.typeZod,
-		rules: zod.array(zod.never()).optional(),
 		meta: Meta.typeZod.optional(),
 		key: zod.string().optional(),
 		restricted: zod.object({ to: Restriction.typeZod.optional() }).optional(),

package/Card/index.ts

@@ -71,12 +71,12 @@ export namespace Card {
 		limit: isly.tuple(isly.fromIs("isoly.Currency", isoly.Currency.is), isly.number()),
 		spent: isly.tuple(isly.fromIs("isoly.Currency", isoly.Currency.is), isly.number()),
 		status: isly.union(isly.string("active"), isly.string("cancelled")),
-		history: isly.array(CardOperation.type),
+		history: CardOperation.type.array(),
 		rules: ruleType.array(),
 		meta: isly.fromIs("Card.Meta", CardMeta.is).optional(),
 		restricted: isly.object<Required<Card>["restricted"]>({ to: CardRestriction.type.optional() }).optional(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Card> = zod.object({
 		id: zod.string(),
 		number: zod.string().optional(),
 		created: zod.string().refine(isoly.DateTime.is),
@@ -96,8 +96,8 @@ export namespace Card {
 		limit: Amount.typeZod,
 		spent: Amount.typeZod,
 		status: zod.enum(["active", "cancelled"]),
-		history: zod.array(CardOperation.typeZod),
-		rules: zod.array(zod.never()),
+		history: CardOperation.typeZod.array(),
+		rules: zod.any().array(),
 		meta: CardMeta.typeZod.optional(),
 		restricted: zod.object({ to: CardRestriction.typeZod.optional() }).optional(),
 	})

package/Merchant/index.ts

@@ -1,6 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 import { Category as MerchantCategory } from "./Category"
 
 export interface Merchant {
@@ -33,6 +33,6 @@ export namespace Merchant {
 		city: zod.string(),
 		zip: zod.string(),
 		state: zod.string().optional(),
-		country: zod.enum(isoly.CountryCode.Alpha2.values),
+		country: zodHelper.countryCode,
 	})
 }

package/Operation/Creatable.ts

@@ -2,7 +2,7 @@ import { cryptly } from "cryptly"
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Settlement } from "../Settlement"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 import { Changes } from "./Changes"
 
 export interface Creatable {
@@ -40,7 +40,7 @@ export namespace Creatable {
 	})
 	export const typeZod = zod.object({
 		account: zod.string(),
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		changes: Changes.typeZod,
 		type: zod.enum(types),
 		counterbalance: zod.string().optional(),

package/Organization/Contact/Address/{General.ts → Default.ts}

@@ -10,7 +10,6 @@ export interface Default {
 	zipCode: string
 	street: string
 }
-
 export namespace Default {
 	export const type = isly.object<Default>({
 		countryCode: isly.string(),
@@ -20,8 +19,8 @@ export namespace Default {
 		street: isly.string(),
 		zipCode: isly.string(),
 	})
-	export const typeZod = zod.object({
-		countryCode: zod.string(),
+	export const typeZod: zod.ZodType<Default> = zod.object({
+		countryCode: zod.string() as any,
 		state: zod.string().optional(),
 		county: zod.string().optional(),
 		city: zod.string(),

package/Organization/Contact/Address/GB.ts

@@ -9,7 +9,6 @@ export interface GB {
 	building: string
 	zipCode: string
 }
-
 export namespace GB {
 	export const name = isoly.CountryCode.Name.en.from("GB")
 	export const type = isly.object<GB>({
@@ -19,7 +18,7 @@ export namespace GB {
 		building: isly.string(),
 		zipCode: isly.string(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<GB> = zod.object({
 		countryCode: zod.literal("GB"),
 		city: zod.string(),
 		street: zod.string(),

package/Organization/Contact/Address/SE.ts

@@ -14,7 +14,7 @@ export namespace SE {
 		city: isly.string(),
 		street: isly.string(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<SE> = zod.object({
 		countryCode: zod.literal("SE"),
 		zipCode: zod.string(),
 		city: zod.string(),

package/Organization/Contact/Address/index.ts

@@ -1,12 +1,12 @@
 import { isly } from "isly"
 import { zod } from "../../../zod"
+import { Default } from "./Default"
 import { GB } from "./GB"
-import { Default } from "./General"
 import { SE } from "./SE"
 
 export type Address = GB | SE | Default
 
 export namespace Address {
 	export const type = isly.union(GB.type, SE.type, Default.type)
-	export const typeZod = zod.union([GB.typeZod, SE.typeZod, Default.typeZod])
+	export const typeZod: zod.ZodType<Address> = zod.union([GB.typeZod, SE.typeZod, Default.typeZod])
 }

package/Organization/Contact/Addresses.ts

@@ -15,7 +15,7 @@ export namespace Addresses {
 		delivery: Address.type.optional(),
 		visit: Address.type.optional(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Addresses> = zod.object({
 		primary: Address.typeZod,
 		billing: Address.typeZod.optional(),
 		delivery: Address.typeZod.optional(),

package/Organization/Contact/Name.ts

@@ -7,5 +7,5 @@ export interface Name {
 }
 export namespace Name {
 	export const type = isly.object<Name>({ first: isly.string(), last: isly.string() })
-	export const typeZod = zod.object({ first: zod.string(), last: zod.string() })
+	export const typeZod: zod.ZodType<Name> = zod.object({ first: zod.string(), last: zod.string() })
 }

package/Organization/Contact/Phone.ts

@@ -1,6 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 
 export interface Phone {
 	number: string
@@ -11,8 +11,8 @@ export namespace Phone {
 		number: isly.string(/^\d+$/),
 		code: isly.fromIs("CallingCode", isoly.CallingCode.is),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Phone> = zod.object({
 		number: zod.string().regex(/^\d+$/),
-		code: zod.custom<isoly.CallingCode>(isoly.CallingCode.is),
+		code: zodHelper.callingCode,
 	})
 }

package/Organization/Contact/index.ts

@@ -26,11 +26,11 @@ export namespace Contact {
 		phone: Phone.type,
 		owners: Name.type.array().optional(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Contact> = zod.object({
 		address: Addresses.typeZod,
 		email: zod.string().regex(/^\S+@\S+\.\S+$/),
 		name: Name.typeZod,
 		phone: Phone.typeZod,
-		owners: zod.array(Name.typeZod).optional(),
+		owners: Name.typeZod.array().optional(),
 	})
 }

package/Organization/Creatable.ts

@@ -1,6 +1,4 @@
 import { isly } from "isly"
-import type { Rule } from "../Rule"
-import { type as ruleType } from "../Rule/type"
 import { zod } from "../zod"
 import { Contact } from "./Contact"
 import { Fx } from "./Fx"
@@ -10,9 +8,7 @@ export interface Creatable {
 	name: string
 	code: string
 	risk: Risk
-	rules?: Rule[]
 	contact?: Contact.Creatable
-	groups?: string[]
 	fx?: Fx
 }
 export namespace Creatable {
@@ -20,18 +16,14 @@ export namespace Creatable {
 		name: isly.string(),
 		code: isly.string(new RegExp(/^[A-Za-z0-9\-_]+$/)),
 		risk: Risk.type,
-		rules: ruleType.array().optional(),
 		contact: Contact.Creatable.type.optional(),
-		groups: isly.string().array().optional(),
 		fx: Fx.type.optional(),
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Creatable> = zod.object({
 		name: zod.string(),
 		code: zod.string().regex(/^[A-Za-z0-9\-_]+$/),
 		risk: Risk.typeZod,
-		rules: zod.array(zod.never()).optional(),
 		contact: Contact.Creatable.typeZod.optional(),
-		groups: zod.array(zod.string()).optional(),
 		fx: Fx.typeZod.optional(),
 	})
 }

package/Organization/index.ts

@@ -40,19 +40,19 @@ export namespace Organization {
 		fx: OrganizationFx.type.optional(),
 		type: Type.type,
 	})
-	export const typeZod = zod.object({
+	export const typeZod: zod.ZodType<Organization> = zod.object({
 		name: zod.string(),
 		code: zod.string().regex(/^[A-Za-z0-9\-_]+$/),
 		realm: Realm.typeZod,
-		rules: zod.array(zod.never()),
+		rules: zod.any().array(),
 		status: zod.enum(["active", "inactive"]),
 		risk: Organization.Risk.typeZod,
 		contact: Contact.typeZod.optional(),
-		groups: zod.array(zod.string()).optional(),
+		groups: zod.string().array().optional(),
 		fx: OrganizationFx.typeZod.optional(),
 		type: Type.typeZod,
 	})
 	export function from(creatable: Creatable, realm: Realm): Organization {
-		return { ...creatable, realm, rules: creatable.rules ?? [], status: "active", type: "emoney" }
+		return { ...creatable, realm, rules: [], status: "active", type: "emoney" }
 	}
 }

package/Rail/index.ts

@@ -20,6 +20,7 @@ export namespace Rail {
 		"sepa-instant",
 		"rix-rtgs",
 		"rix-inst",
+		"swift",
 	] as const
 	export const type = isly.string<Rail>(rails)
 	export const typeZod = zod.enum(rails)

package/Rule/index.ts

@@ -2,7 +2,7 @@ import { isly } from "isly"
 import { State as RuleState } from "./State"
 import { type as ruleType } from "./type"
 
-export type Rule = never
+export type Rule = any
 export namespace Rule {
 	export import State = RuleState
 	export type Kind = (typeof Kind.values)[number]

package/Settlement/Totals.ts

@@ -1,13 +1,13 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 import { Entry } from "./Entry"
 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.values), Total.type)
-	export const typeZod: zod.ZodType<Totals> = zod.partialRecord(zod.enum(isoly.Currency.values), Total.typeZod)
+	export const typeZod: zod.ZodType<Totals> = zod.partialRecord(zodHelper.currency, Total.typeZod)
 	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

@@ -3,7 +3,7 @@ import { isly } from "isly"
 import { Account } from "../Account"
 import { Preset } from "../Card/Preset"
 import { Rail } from "../Rail"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 import { Amount } from "./Amount"
 import { Exchange } from "./Exchange"
 
@@ -27,7 +27,7 @@ export namespace Creatable {
 	})
 	export const typeZod = zod.object({
 		counterpart: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		amount: zod.number(),
 		description: zod.string(),
 		exchange: Exchange.typeZod.optional(),

package/Transaction/Incoming.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../Rail"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 import { Reference as TransactionReference } from "./Reference"
 
 export interface Incoming {
@@ -28,7 +28,7 @@ export namespace Incoming {
 	export const typeZod = zod.object({
 		account: Rail.Address.typeZod,
 		counterpart: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		amount: zod.number(),
 		description: zod.string(),
 		posted: zod.string(),

package/Transaction/PreTransaction/Base.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../../Rail"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 import { Exchange } from "../Exchange"
 
 export interface Base {
@@ -24,7 +24,7 @@ export namespace Base {
 	export const typeZod = zod.object({
 		type: zod.enum(["outgoing", "incoming", "authorization"]),
 		counterpart: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		amount: zod.number(),
 		description: zod.string(),
 		exchange: Exchange.typeZod.optional(),

package/Transaction/PreTransaction/Incoming.ts

@@ -2,7 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../../Rail"
 import { Settlement } from "../../Settlement"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 import { Reference as TransactionReference } from "../Reference"
 import { Base } from "./Base"
 
@@ -30,7 +30,7 @@ export namespace Incoming {
 	export const typeZod = Base.typeZod.extend({
 		type: zod.literal("incoming"),
 		account: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		amount: zod.number(),
 		description: zod.string(),
 		posted: zod.string(),

package/Transaction/index.ts

@@ -7,7 +7,7 @@ import { Rail } from "../Rail"
 import { Report } from "../Report"
 import type { Rule } from "../Rule"
 import { Settlement } from "../Settlement"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 import { Amount as TransactionAmount } from "./Amount"
 import { Creatable as TransactionCreatable } from "./Creatable"
 import { Exchange as TransactionExchange } from "./Exchange"
@@ -88,7 +88,7 @@ export namespace Transaction {
 	})
 	export const typeZod = zod.object({
 		counterpart: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		amount: Amount.typeZod,
 		description: zod.string(),
 		organization: zod.string(),

package/Treasury/Snapshot/Account.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Warning } from "../../Warning"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 import { Transaction } from "../Transaction"
 
 export interface Account {
@@ -53,7 +53,7 @@ export namespace Account {
 		label: zod.string(),
 		reference: zod.string(),
 		description: zod.string().optional(),
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		opening: Opening.typeZod.optional(),
 		closing: Closing.typeZod,
 		delta: Delta.typeZod,

package/Treasury/Snapshot/Emoney.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { Balances } from "../../Balances"
 import { Supplier } from "../../Supplier"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 
 export interface Emoney {
 	organization: string
@@ -18,7 +18,7 @@ export namespace Emoney {
 		account: zod.string(),
 		created: zod.string().refine(isoly.DateTime.is).optional(),
 		supplier: Supplier.typeZod.optional(),
-		currencies: zod.array(zod.enum(isoly.Currency.values)).optional(),
+		currencies: zod.array(zodHelper.currency).optional(),
 		timestamp: zod.string().refine(isoly.DateTime.is),
 		balances: Balances.typeZod,
 	})

package/Treasury/Snapshot/funding.ts

@@ -1,6 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 import { Transaction } from "../Transaction"
 
 export namespace funding {
@@ -24,7 +24,7 @@ export namespace funding {
 	export type Cursors = Partial<Record<isoly.Currency, Cursor>>
 	export namespace Cursors {
 		export const type = isly.record<Cursors>(isly.fromIs("isoly.Currency", isoly.Currency.is), Cursor.type)
-		export const typeZod: zod.ZodType<Cursors> = zod.partialRecord(zod.enum(isoly.Currency.values), Cursor.typeZod)
+		export const typeZod: zod.ZodType<Cursors> = zod.partialRecord(zodHelper.currency, Cursor.typeZod)
 		export function updateAmount(settlement: Transaction, cursors: Cursors): Cursors {
 			const cursor = cursors[settlement.currency]
 			if (!cursor) {

package/Treasury/Snapshot/index.ts

@@ -3,7 +3,7 @@ import { Balance } from "../../Balance"
 import { Supplier } from "../../Supplier"
 import { Transaction } from "../../Transaction"
 import { Warning } from "../../Warning"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 import { Account as SnapshotAccount } from "./Account"
 import { Check as SnapshotCheck } from "./Check"
 import { Emoney as SnapshotEmoney } from "./Emoney"
@@ -58,7 +58,7 @@ export namespace Snapshot {
 			accounts: zod.array(EmoneyAccounts.typeZod),
 		}),
 		created: zod.string().refine(isoly.DateTime.is),
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		supplier: Supplier.typeZod,
 		fiat: zod.object({
 			total: zod.number(),

package/Treasury/Transaction/Creatable.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../../Rail"
-import { zod } from "../../zod"
+import { zod, zodHelper } from "../../zod"
 
 export interface Creatable {
 	creditor: Rail.Address
@@ -20,7 +20,7 @@ export namespace Creatable {
 	})
 	export const typeZod = zod.object({
 		creditor: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
+		currency: zodHelper.currency,
 		amount: zod.number(),
 		description: zod.string(),
 		external: zod.string().optional(),

package/Warning/Issue.ts

@@ -1,6 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { zod } from "../zod"
+import { zod, zodHelper } from "../zod"
 
 export interface Issue {
 	link: string
@@ -30,7 +30,7 @@ export namespace Issue {
 		})
 		export const typeZod: zod.ZodType<Creatable> = zod.object({
 			type: zod.string(),
-			currency: zod.enum(isoly.Currency.values),
+			currency: zodHelper.currency,
 			resource: zod.string().optional(),
 			issue: Issue.typeZod,
 		})