@pax2pay/model-banking 0.1.670 → 0.1.672

package/Organization/Contact/Creatable.ts

@@ -19,11 +19,13 @@ export namespace Creatable {
 		phone: Phone.type,
 		owners: Name.type.array({ criteria: "minLength", value: 1 }),
 	})
-	export const typeZod = zod.object({
-		address: Addresses.typeZod,
-		email: zod.string().regex(/^\S+@\S+\.\S+$/),
-		name: Name.typeZod,
-		phone: Phone.typeZod,
-		owners: zod.array(Name.typeZod).min(1),
-	})
+	export const typeZod = zod
+		.object({
+			address: Addresses.typeZod,
+			email: zod.string().regex(/^\S+@\S+\.\S+$/),
+			name: Name.typeZod,
+			phone: Phone.typeZod,
+			owners: Name.typeZod.array().min(1),
+		})
+		.meta({ id: "Organization.Contact.Creatable" })
 }

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,16 @@ 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({
-		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(),
-	})
+	export const typeZod: zod.ZodType<Creatable> = zod
+		.object({
+			name: zod.string(),
+			code: zod.string().regex(/^[A-Za-z0-9\-_]+$/),
+			risk: Risk.typeZod,
+			contact: Contact.Creatable.typeZod.optional(),
+			fx: Fx.typeZod.optional(),
+		})
+		.meta({ id: "Organization.Creatable" })
 }

package/Organization/Risk.ts

@@ -2,9 +2,8 @@ import { isly } from "isly"
 import { zod } from "../zod"
 
 export type Risk = (typeof Risk.values)[number]
-
 export namespace Risk {
 	export const values = ["low", "medium", "high", "prohibited"] as const
 	export const type = isly.string(values)
-	export const typeZod = zod.enum(values)
+	export const typeZod = zod.enum(values).meta({ id: "Organization.Risk" })
 }

package/Organization/index.ts

@@ -40,19 +40,21 @@ export namespace Organization {
 		fx: OrganizationFx.type.optional(),
 		type: Type.type,
 	})
-	export const typeZod = zod.object({
-		name: zod.string(),
-		code: zod.string().regex(/^[A-Za-z0-9\-_]+$/),
-		realm: Realm.typeZod,
-		rules: zod.array(zod.never()),
-		status: zod.enum(["active", "inactive"]),
-		risk: Organization.Risk.typeZod,
-		contact: Contact.typeZod.optional(),
-		groups: zod.array(zod.string()).optional(),
-		fx: OrganizationFx.typeZod.optional(),
-		type: Type.typeZod,
-	})
+	export const typeZod: zod.ZodType<Organization> = zod
+		.object({
+			name: zod.string(),
+			code: zod.string().regex(/^[A-Za-z0-9\-_]+$/),
+			realm: Realm.typeZod,
+			rules: zod.any().array(),
+			status: zod.enum(["active", "inactive"]),
+			risk: Organization.Risk.typeZod,
+			contact: Contact.typeZod.optional(),
+			groups: zod.string().array().optional(),
+			fx: OrganizationFx.typeZod.optional(),
+			type: Type.typeZod,
+		})
+		.meta({ id: "Organization" })
 	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/Address/index.ts

@@ -95,16 +95,17 @@ export namespace Address {
 		AddressScan.type,
 		AddressBic.type
 	)
-	export const typeZod = zod.union([
-		AddressCard.typeZod,
-		AddressCard.Counterpart.typeZod,
-		AddressIban.typeZod,
-		AddressInternal.typeZod,
-		AddressPaxGiro.typeZod,
-		AddressScan.typeZod,
-		AddressBic.typeZod,
-	])
-
+	export const typeZod = zod
+		.union([
+			AddressCard.typeZod,
+			AddressCard.Counterpart.typeZod,
+			AddressIban.typeZod,
+			AddressInternal.typeZod,
+			AddressPaxGiro.typeZod,
+			AddressScan.typeZod,
+			AddressBic.typeZod,
+		])
+		.meta({ id: "Rail.Address" })
 	export import PaxGiro = AddressPaxGiro
 	export import Iban = AddressIban
 	export import Scan = AddressScan

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/Amount.ts

@@ -13,10 +13,9 @@ export namespace Amount {
 		net: isly.number(),
 		fee: isly.object<Amount["fee"]>({ other: isly.number() }),
 	})
-	export const typeZod: zod.ZodType<Amount> = zod.object({
-		net: zod.number(),
-		fee: zod.object({ other: zod.number() }),
-	})
+	export const typeZod: zod.ZodType<Amount> = zod
+		.object({ net: zod.number(), fee: zod.object({ other: zod.number() }) })
+		.meta({ id: "Settlement.Amount" })
 	export function sum(currency: isoly.Currency, amount: Amount | undefined): number {
 		return isoly.Currency.add(currency, amount?.net ?? 0, amount?.fee.other ?? 0)
 	}

package/Settlement/Creatable.ts

@@ -20,11 +20,13 @@ export namespace Creatable {
 		batch: Batch.type,
 		count: isly.number().optional(),
 	})
-	export const typeZod = zod.object({
-		totals: Totals.typeZod,
-		processor: Card.Stack.typeZod,
-		references: zod.array(zod.string()).optional(),
-		batch: Batch.typeZod,
-		count: zod.number().optional(),
-	}) satisfies zod.ZodType<Creatable>
+	export const typeZod = zod
+		.object({
+			totals: Totals.typeZod,
+			processor: Card.Stack.typeZod,
+			references: zod.array(zod.string()).optional(),
+			batch: Batch.typeZod,
+			count: zod.number().optional(),
+		})
+		.meta({ id: "Settlement.Creatable" }) satisfies zod.ZodType<Creatable>
 }

package/Settlement/Entry/Creatable.ts

@@ -95,5 +95,7 @@ export namespace Creatable {
 		})
 	}
 	export const type = isly.union(Known.type, Unknown.type)
-	export const typeZod: zod.ZodType<Creatable> = zod.union([Known.typeZod, Unknown.typeZod])
+	export const typeZod: zod.ZodType<Creatable> = zod
+		.union([Known.typeZod, Unknown.typeZod])
+		.meta({ id: "Settlement.Entry.Creatable" })
 }

package/Settlement/Entry/index.ts

@@ -23,7 +23,7 @@ export namespace Entry {
 	export import Succeeded = EntrySucceeded
 	export import Summary = EntrySummary
 	export const type = entryType
-	export const typeZod = entryTypeZod
+	export const typeZod = entryTypeZod.meta({ id: "Settlement.Entry" })
 	export const from = fromCreatable
 	export function charge(
 		counterpart: Rail.Address.Card.Counterpart,

package/Settlement/Status.ts

@@ -5,7 +5,6 @@ export interface Status {
 	collected: Status.Values
 	settled: Status.Values
 }
-
 export namespace Status {
 	export const values = ["pending", "failed", "partial", "done"] as const
 	export type Values = (typeof values)[number]
@@ -13,8 +12,7 @@ export namespace Status {
 		collected: isly.string(values),
 		settled: isly.string(values),
 	})
-	export const typeZod: zod.ZodType<Status> = zod.object({
-		collected: zod.enum(values),
-		settled: zod.enum(values),
-	})
+	export const typeZod: zod.ZodType<Status> = zod
+		.object({ collected: zod.enum(values), settled: zod.enum(values) })
+		.meta({ id: "Settlement.Status" })
 }

package/Settlement/Total.ts

@@ -48,12 +48,14 @@ export namespace Total {
 		collected: Collected.type.optional(),
 		settled: Settled.optional(),
 	})
-	export const typeZod: zod.ZodType<Total> = zod.object({
-		expected: Amount.typeZod,
-		outcome: Amount.typeZod.optional(),
-		collected: Collected.typeZod.optional(),
-		settled: SettledZod.optional(),
-	})
+	export const typeZod: zod.ZodType<Total> = zod
+		.object({
+			expected: Amount.typeZod,
+			outcome: Amount.typeZod.optional(),
+			collected: Collected.typeZod.optional(),
+			settled: SettledZod.optional(),
+		})
+		.meta({ id: "Settlement.Total" })
 	export function create(): Total {
 		return { expected: { net: 0, fee: { other: 0 } } }
 	}

package/Settlement/Totals.ts

@@ -1,13 +1,15 @@
 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)
+		.meta({ id: "Settlement.Totals" })
 	export function addEntry(totals: Totals, entry: Entry): Totals {
 		const result = { ...totals }
 		if (entry.status == "succeeded" && (entry.type == "capture" || entry.type == "refund")) {

package/Settlement/index.ts

@@ -75,12 +75,14 @@ export namespace Settlement {
 		entries: Settlement.Entry.Summary.type,
 		warnings: Settlement.Warning.type.array().optional(),
 	})
-	export const typeZod: zod.ZodType<Settlement> = SettlementCreatable.typeZod.extend({
-		id: zod.union([SettlementIdentifier.typeZod, zod.string()]),
-		by: zod.string().optional(),
-		created: zod.string().refine(isoly.DateTime.is),
-		status: Status.typeZod,
-		entries: Settlement.Entry.Summary.typeZod,
-		warnings: zod.array(Settlement.Warning.typeZod).optional(),
-	})
+	export const typeZod: zod.ZodType<Settlement> = SettlementCreatable.typeZod
+		.extend({
+			id: zod.union([SettlementIdentifier.typeZod, zod.string()]),
+			by: zod.string().optional(),
+			created: zod.string().refine(isoly.DateTime.is),
+			status: Status.typeZod,
+			entries: Settlement.Entry.Summary.typeZod,
+			warnings: zod.array(Settlement.Warning.typeZod).optional(),
+		})
+		.meta({ id: "Settlement" })
 }

package/Supplier/index.ts

@@ -7,7 +7,7 @@ export type Supplier = (typeof Supplier.names)[number]
 export namespace Supplier {
 	export const names = ["paxgiro", "clearbank", "bankingcircle"] as const
 	export const type = isly.string<Supplier>(names)
-	export const typeZod = zod.enum(names)
+	export const typeZod = zod.enum(names).meta({ id: "Supplier" })
 	export const decommissioned = ["clearbank"] as const
 	export type Decommissioned = (typeof decommissioned)[number]
 	export function isDecommissioned(supplier: Supplier | any): supplier is Decommissioned {

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"
 
@@ -25,14 +25,16 @@ export namespace Creatable {
 		exchange: Exchange.type.optional(),
 		reference: isly.object<{ reference?: string }>({ reference: isly.string().optional() }).optional(),
 	})
-	export const typeZod = zod.object({
-		counterpart: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
-		amount: zod.number(),
-		description: zod.string(),
-		exchange: Exchange.typeZod.optional(),
-		reference: zod.object({ reference: zod.string().optional() }).optional(),
-	})
+	export const typeZod = zod
+		.object({
+			counterpart: Rail.Address.typeZod,
+			currency: zodHelper.currency,
+			amount: zod.number(),
+			description: zod.string(),
+			exchange: Exchange.typeZod.optional(),
+			reference: zod.object({ reference: zod.string().optional() }).optional(),
+		})
+		.meta({ id: "Transaction.Creatable" })
 	export interface CardTransaction extends Creatable {
 		account: Pick<Rail.Address.Card, "id" | "type">
 		accountId: string
@@ -48,13 +50,15 @@ export namespace Creatable {
 			reference: isly.object<{ reference: string }>({ reference: isly.string() }),
 			approvalCode: isly.string().optional(),
 		})
-		export const typeZod = Creatable.typeZod.extend({
-			account: Rail.Address.Card.typeZod.pick({ id: true, type: true }),
-			accountId: zod.string(),
-			counterpart: Rail.Address.Card.Counterpart.typeZod,
-			reference: zod.object({ reference: zod.string() }),
-			approvalCode: zod.string().optional(),
-		})
+		export const typeZod = Creatable.typeZod
+			.extend({
+				account: Rail.Address.Card.typeZod.pick({ id: true, type: true }),
+				accountId: zod.string(),
+				counterpart: Rail.Address.Card.Counterpart.typeZod,
+				reference: zod.object({ reference: zod.string() }),
+				approvalCode: zod.string().optional(),
+			})
+			.meta({ id: "Transaction.Creatable.CardTransaction" })
 		export function charge(creatable: CardTransaction, preset: Preset, charges?: Account.Charge): Amount.Charge {
 			return Account.Charge.evaluate(
 				creatable.counterpart,

package/Transaction/Exchange.ts

@@ -15,10 +15,12 @@ export namespace Exchange {
 		from: Amount.type.optional(),
 		quote: isly.string().optional(),
 	})
-	export const typeZod = zod.object({
-		rate: zod.number(),
-		to: Amount.typeZod.optional(),
-		from: Amount.typeZod.optional(),
-		quote: zod.string().optional(),
-	})
+	export const typeZod: zod.ZodType<Exchange> = zod
+		.object({
+			rate: zod.number(),
+			to: Amount.typeZod.optional(),
+			from: Amount.typeZod.optional(),
+			quote: zod.string().optional(),
+		})
+		.meta({ id: "Transaction.Exchange" })
 }

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/Note.ts

@@ -33,19 +33,20 @@ export namespace Note {
 			flags: isly.string().array().optional(),
 			rule: isly.any().optional(),
 		})
-		export const typeZod = zod.object({
-			text: zod.string().optional(),
-			action: zod.enum(["approve", "reject"]).optional(),
-			flags: zod.array(zod.string()).optional(),
-			rule: zod.any().optional(),
-		})
+		export const typeZod = zod
+			.object({
+				text: zod.string().optional(),
+				action: zod.enum(["approve", "reject"]).optional(),
+				flags: zod.array(zod.string()).optional(),
+				rule: zod.any().optional(),
+			})
+			.meta({ id: "Transaction.Note.Creatable" })
 	}
 	export const type = Creatable.type.extend<Note>({
 		author: isly.string(),
 		created: isly.string(),
 	})
-	export const typeZod = Creatable.typeZod.extend({
-		author: zod.string(),
-		created: zod.string().refine(isoly.DateTime.is),
-	})
+	export const typeZod = Creatable.typeZod
+		.extend({ author: zod.string(), created: zod.string().refine(isoly.DateTime.is) })
+		.meta({ id: "Transaction.Note" })
 }

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/Status.ts

@@ -28,5 +28,7 @@ export namespace Status {
 		Success,
 		isly.tuple<[Fail, Status.Reason]>(Fail, Reason)
 	)
-	export const typeZod = zod.union([zod.enum(successes), zod.tuple([zod.enum(failures), zod.enum(reasons)])])
+	export const typeZod = zod
+		.union([zod.enum(successes), zod.tuple([zod.enum(failures), zod.enum(reasons)])])
+		.meta({ id: "Transaction.Status" })
 }

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"
@@ -86,32 +86,34 @@ export namespace Transaction {
 		risk: isly.number().optional(),
 		state: isly.any().optional(),
 	})
-	export const typeZod = zod.object({
-		counterpart: Rail.Address.typeZod,
-		currency: zod.enum(isoly.Currency.values),
-		amount: Amount.typeZod,
-		description: zod.string(),
-		organization: zod.string(),
-		accountId: zod.string(),
-		accountName: zod.string().optional(),
-		account: Rail.Address.typeZod,
-		type: zod.enum(types).optional(),
-		direction: zod.enum(directions).optional(),
-		id: Identifier.typeZod,
-		reference: Reference.typeZod.optional(),
-		posted: zod.string().refine(isoly.DateTime.is),
-		transacted: zod.string().refine(isoly.DateTime.is).optional(),
-		by: zod.string().optional(),
-		balance: zod.object({ actual: zod.number(), available: zod.number(), reserved: zod.number() }),
-		operations: zod.array(Operation.typeZod).optional(),
-		status: Status.typeZod,
-		rail: Rail.typeZod.optional(),
-		flags: zod.array(zod.string()),
-		oldFlags: zod.array(zod.string()),
-		notes: zod.array(Note.typeZod),
-		risk: zod.number().optional(),
-		state: zod.any().optional(),
-	})
+	export const typeZod = zod
+		.object({
+			counterpart: Rail.Address.typeZod,
+			currency: zodHelper.currency,
+			amount: Amount.typeZod,
+			description: zod.string(),
+			organization: zod.string(),
+			accountId: zod.string(),
+			accountName: zod.string().optional(),
+			account: Rail.Address.typeZod,
+			type: zod.enum(types).optional(),
+			direction: zod.enum(directions).optional(),
+			id: Identifier.typeZod,
+			reference: Reference.typeZod.optional(),
+			posted: zod.string().refine(isoly.DateTime.is),
+			transacted: zod.string().refine(isoly.DateTime.is).optional(),
+			by: zod.string().optional(),
+			balance: zod.object({ actual: zod.number(), available: zod.number(), reserved: zod.number() }),
+			operations: zod.array(Operation.typeZod).optional(),
+			status: Status.typeZod,
+			rail: Rail.typeZod.optional(),
+			flags: zod.array(zod.string()),
+			oldFlags: zod.array(zod.string()),
+			notes: zod.array(Note.typeZod),
+			risk: zod.number().optional(),
+			state: zod.any().optional(),
+		})
+		.meta({ id: "Transaction" })
 	export function amountFromOperations(transaction: Transaction, operations: Operation[]): Amount {
 		const changes = Operation.sum(operations)
 		const reserved = isoly.Currency.add(
@@ -413,9 +415,9 @@ export namespace Transaction {
 			account: Rail.Address.Card.type,
 			counterpart: Rail.Address.Card.Counterpart.type,
 		})
-		export const typeZod = Transaction.typeZod.omit({ account: true, counterpart: true }).extend({
-			account: Rail.Address.Card.typeZod,
-			counterpart: Rail.Address.Card.Counterpart.typeZod,
-		})
+		export const typeZod = Transaction.typeZod
+			.omit({ account: true, counterpart: true })
+			.extend({ account: Rail.Address.Card.typeZod, counterpart: Rail.Address.Card.Counterpart.typeZod })
+			.meta({ id: "Transaction.CardTransaction" })
 	}
 }

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/Check/Base.ts

@@ -7,8 +7,5 @@ export interface Base {
 	result: Result
 }
 export namespace Base {
-	export const typeZod = zod.object({
-		check: Checks.typeZod,
-		result: Result.typeZod,
-	}) satisfies zod.ZodType<Base>
+	export const typeZod = zod.object({ check: Checks.typeZod, result: Result.typeZod }) satisfies zod.ZodType<Base>
 }