@pax2pay/model-banking 0.1.657 → 0.1.659

package/Account/Charge/Fx/index.ts

@@ -8,6 +8,7 @@ export type Fx = Preset
 
 export namespace Fx {
 	export const type = Preset.type
+	export const typeZod = Preset.typeZod
 	export function evaluate(
 		charge: Fx,
 		currency: isoly.Currency,

package/Account/Charge/Merchant/index.ts

@@ -3,6 +3,7 @@ import { isly } from "isly"
 import { Card } from "../../../Card"
 import { Rail } from "../../../Rail"
 import { Amount } from "../../../Transaction/Amount"
+import { zod } from "../../../zod"
 import { Preset } from "../Preset"
 
 export interface Merchant {
@@ -16,6 +17,10 @@ export namespace Merchant {
 		}),
 		merchants: isly.record<Card.Restriction.Merchant, Preset>(Card.Restriction.Merchant.type, Preset.type),
 	})
+	export const typeZod = zod.object({
+		destination: zod.object({ account: zod.string() }),
+		merchants: zod.partialRecord(Card.Restriction.Merchant.typeZod, Preset.typeZod),
+	})
 
 	export function evaluate(
 		charge: Merchant,

package/Account/Charge/Preset/index.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Card } from "../../../Card"
+import { zod } from "../../../zod"
 
 export type Preset = Partial<Record<Card.Preset, number>> & {
 	default: number
@@ -12,4 +13,7 @@ export namespace Preset {
 		return defaultType.is(value) && recordType.is((({ default: _, ...rest }) => rest)(value))
 	}
 	export const type = isly.fromIs("Preset", is)
+	export const typeZod = zod
+		.partialRecord(zod.enum([...Card.Preset.names, "default"]), zod.number())
+		.and(zod.object({ default: zod.number() }))
 }

package/Account/Charge/index.ts

@@ -3,6 +3,7 @@ import { isly } from "isly"
 import type { Card } from "../../Card"
 import type { Rail } from "../../Rail"
 import type { Transaction } from "../../Transaction"
+import { zod } from "../../zod"
 import { Fx as ChargeFx } from "./Fx"
 import { Merchant as ChargeMerchant } from "./Merchant"
 
@@ -11,6 +12,10 @@ export namespace Charge {
 	export import Merchant = ChargeMerchant
 	export import Fx = ChargeFx
 	export const type = isly.object<Charge>({ merchant: ChargeMerchant.type.optional(), fx: ChargeFx.type.optional() })
+	export const typeZod = zod.object({
+		merchant: ChargeMerchant.typeZod.optional(),
+		fx: ChargeFx.typeZod.optional(),
+	})
 	export function evaluate(
 		counterpart: Rail.Address.Card.Counterpart,
 		currency: isoly.Currency,

package/Account/Creatable.ts

@@ -1,5 +1,6 @@
 import { DurableObjectLocationHint } from "@cloudflare/workers-types" // TODO: REMOVE
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export interface Creatable {
 	name: string
@@ -14,6 +15,8 @@ export namespace Creatable {
 		}
 		// All location hints: ["wnam", "enam", "sam", "weur", "eeur", "apac", "oc", "afr", "me"]
 		export const type = isly.string(values)
+		export const typeZod = zod.enum(values)
 	}
 	export const type = isly.object<Creatable>({ name: isly.string(), location: Location.type.optional() })
+	export const typeZod = zod.object({ name: zod.string(), location: Location.typeZod.optional() })
 }

package/Account/Details.ts

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

package/Account/History.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export type History = {
 	timestamp: isoly.DateTime
@@ -21,10 +22,16 @@ export namespace History {
 			"listeners",
 		] as const
 		export const type = isly.string<Property>(values)
+		export const typeZod = zod.enum(values)
 	}
 	export const type = isly.object<History>({
 		timestamp: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 		property: Property.type,
 		to: isly.any().optional(),
 	})
+	export const typeZod = zod.object({
+		timestamp: zod.string().refine(isoly.DateTime.is),
+		property: Property.typeZod,
+		to: zod.any().optional(),
+	})
 }

package/Account/Status.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export type Status = {
 	mode: Status.Mode
@@ -17,4 +18,8 @@ export namespace Status {
 		mode: isly.string<Mode>(Mode.values),
 		reason: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		mode: zod.enum(Mode.values),
+		reason: zod.string().optional(),
+	})
 }

package/Account/index.ts

@@ -4,6 +4,7 @@ import { isly } from "isly"
 import { Balances } from "../Balances"
 import { Rail } from "../Rail"
 import { Rule } from "../Rule"
+import { zod } from "../zod"
 import { Charge as AccountCharge } from "./Charge"
 import { Creatable as AccountCreatable } from "./Creatable"
 import { Details as AccountDetails } from "./Details"
@@ -42,6 +43,18 @@ export namespace Account {
 		status: AccountStatus.type,
 		type: Type.type,
 	})
+	export const typeZod = Creatable.typeZod.extend({
+		id: zod.string(),
+		created: zod.string().refine(isoly.DateTime.is),
+		organization: zod.string(),
+		balances: Balances.typeZod,
+		rails: zod.array(Rail.Address.typeZod),
+		details: Details.typeZod.optional(),
+		charges: AccountCharge.typeZod.optional(),
+		rules: zod.array(zod.never()).optional(),
+		status: AccountStatus.typeZod,
+		type: Type.typeZod,
+	})
 	export function isIdentifier(value: cryptly.Identifier | any): value is cryptly.Identifier {
 		return cryptly.Identifier.is(value, 8)
 	}

package/Acquirer/index.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export interface Acquirer {
 	id: string
@@ -16,4 +17,11 @@ export namespace Acquirer {
 		retrievalReferenceNumber: isly.string().optional(),
 		systemTraceAuditNumber: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		id: zod.string(),
+		number: zod.string(),
+		country: zod.string().refine(isoly.CountryCode.Alpha2.is).optional(),
+		retrievalReferenceNumber: zod.string().optional(),
+		systemTraceAuditNumber: zod.string().optional(),
+	})
 }

package/Amount.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amounts } from "./Amounts"
+import { zod } from "./zod"
 
 export type Amount = [isoly.Currency, number]
 
@@ -9,4 +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()])
 }

package/Balance.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amount } from "./Amount"
+import { zod } from "./zod"
 
 export type Balance = { available?: number; reserved?: Balance.Reserved }
 export namespace Balance {
@@ -8,27 +9,42 @@ export namespace Balance {
 	export namespace Reserve {
 		export const values = ["incoming", "outgoing", "buffer"] as const
 		export const type = isly.string<Reserve>(values)
+		export const typeZod = zod.enum(values)
 	}
 	export type Reserved = Partial<Record<Balance.Reserve, number>>
 	export const type = isly.object<Balance>({
 		available: isly.number().optional(),
 		reserved: isly.record<Reserved>(Balance.Reserve.type, isly.number().optional()).optional(),
 	})
+	export const typeZod = zod.object({
+		available: zod.number().optional(),
+		reserved: zod.partialRecord(Balance.Reserve.typeZod, zod.number().optional()).optional(),
+	})
 	export type Legacy = Partial<Record<Legacy.Entry, number>>
 	export namespace Legacy {
 		export type Entry = (typeof Entry.values)[number]
 		export namespace Entry {
 			export const values = ["actual", "incomingReserved", "outgoingReserved", "bufferReserved"] as const
 			export const type = isly.string<Entry>(values)
+			export const typeZod = zod.enum(values)
 		}
 		export const type = isly.record<Legacy>(Entry.type, isly.number())
+		export const typeZod = zod.partialRecord(Entry.typeZod, zod.number())
 	}
 	export type MaybeLegacy = Balance | Legacy
 	export namespace MaybeLegacy {
 		export const legacyType = isly.union<MaybeLegacy>(type, Legacy.type)
 	}
 	export type Extended = Balance & Legacy
-	export const Extended = isly.intersection<Extended, Balance, Legacy>(type, Legacy.type)
+	export namespace Extended {
+		export const type = isly.intersection<Extended, Balance, Legacy>(Balance.type, Legacy.type)
+		export const typeZod = Balance.typeZod.extend({
+			actual: zod.number().optional(),
+			incomingReserved: zod.number().optional(),
+			outgoingReserved: zod.number().optional(),
+			bufferReserved: zod.number().optional(),
+		})
+	}
 	export function update(currency: isoly.Currency, balance: MaybeLegacy): Extended {
 		const result: Extended = { ...balance }
 		if (Legacy.type.is(balance)) {

package/Balances.ts

@@ -2,12 +2,14 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amounts } from "./Amounts"
 import { Balance as BalancesBalance } from "./Balance"
+import { zod } 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 function update(balances: Balances): Balances {
 		const result: Balances = {}
 		for (const [currency, balance] of Object.entries(balances)) {

package/Card/Changeable.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amount } from "../Amount"
+import { zod } from "../zod"
 import { Meta } from "./Meta"
 
 export type Changeable = {
@@ -13,4 +14,8 @@ 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 typeZod = zod.object({
+		limit: Amount.typeZod.optional(),
+		meta: Meta.typeZod.optional(),
+	})
 }

package/Card/Creatable.ts

@@ -3,6 +3,7 @@ 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"
 import { Preset } from "./Preset"
@@ -35,4 +36,15 @@ export namespace Creatable {
 		key: isly.string().optional(),
 		restricted: isly.object<Required<Creatable>["restricted"]>({ to: Restriction.type.optional() }).optional(),
 	})
+	export const typeZod = 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/Expiry.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 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,7 @@ 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 typeZod = zod.tuple([zod.literal([...year]), zod.literal([...month])])
 	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/Meta.ts

@@ -1,3 +1,5 @@
+import { zod } from "../zod"
+
 export interface Meta {
 	[key: string]: any
 }
@@ -14,4 +16,5 @@ export namespace Meta {
 			typeof value == "boolean"
 		)
 	}
+	export const typeZod = zod.any().refine(Meta.is)
 }

package/Card/Operation/Authorization.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 
 export interface Authorization {
 	type: "authorization"
@@ -18,4 +19,11 @@ export namespace Authorization {
 		reason: isly.string().optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("authorization"),
+		id: zod.string(),
+		status: zod.enum(statuses),
+		reason: zod.string().optional(),
+		created: zod.string().refine(isoly.DateTime.is),
+	})
 }

package/Card/Operation/Card.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { Changeable } from "../Changeable"
 
 export interface Card {
@@ -18,4 +19,10 @@ export namespace Card {
 		from: Changeable.type.optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("card"),
+		status: zod.enum(statuses),
+		from: Changeable.typeZod.optional(),
+		created: zod.string().refine(isoly.DateTime.is),
+	})
 }

package/Card/Operation/index.ts

@@ -2,6 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Authorization } from "../../Authorization"
 import { Entry } from "../../Settlement/Entry"
+import { zod } from "../../zod"
 import { Authorization as OperationAuthorization } from "./Authorization"
 import { Card } from "./Card"
 
@@ -27,4 +28,5 @@ export namespace Operation {
 				}
 	}
 	export const type = isly.union(Card.type, OperationAuthorization.type)
+	export const typeZod = zod.union([Card.typeZod, OperationAuthorization.typeZod])
 }

package/Card/Preset.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Realm } from "../Realm"
+import { zod } from "../zod"
 import { Stack } from "./Stack"
 
 export type Preset = (typeof Preset.names)[number]
@@ -25,6 +26,7 @@ export namespace Preset {
 		"test-diners-175",
 	] as const
 	export const type = isly.string<Preset>(names)
+	export const typeZod = zod.enum(names)
 	export const forRealm: Record<Realm, Preset[]> = {
 		test: ["test-pg-150", "test-pg-200", "test-ta-mc-200", "test-ta-pg-200", "test-ta-pg-bc-200", "test-diners-175"],
 		uk: [

package/Card/Restriction/Merchant.ts

@@ -1,6 +1,7 @@
 import { isly } from "isly"
 import { typedly } from "typedly"
 import { Rail } from "../../Rail"
+import { zod } from "../../zod"
 import { merchants } from "./merchants"
 import { Merchant as Attribute } from "./merchants/Merchant"
 
@@ -8,6 +9,7 @@ export type Merchant = (typeof Merchant.values)[number]
 export namespace Merchant {
 	export const values = typedly.Object.keys(merchants)
 	export const type = isly.string<Merchant>(values)
+	export const typeZod = zod.enum(values)
 	export function check(merchant: Merchant, counterpart: Rail.Address.Card.Counterpart): boolean {
 		const attribute: Attribute = merchants[merchant]
 		let result: boolean

package/Card/Restriction/index.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import type { Transaction } from "../../Transaction"
+import { zod } from "../../zod"
 import { Merchant as RestrictionsMerchant } from "./Merchant"
 
 export interface Restriction {
@@ -8,6 +9,7 @@ export interface Restriction {
 export namespace Restriction {
 	export import Merchant = RestrictionsMerchant
 	export const type = isly.object<Restriction>({ merchants: Merchant.type.array().optional() })
+	export const typeZod = zod.object({ merchants: zod.array(Merchant.typeZod).optional() })
 	export function check(
 		restrictions: Restriction,
 		transaction: Transaction.Creatable.CardTransaction | Transaction.PreTransaction.Authorization

package/Card/Scheme.ts

@@ -1,7 +1,9 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 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 typeZod = zod.enum(schemes)
 }

package/Card/Stack.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Realm } from "../Realm"
+import { zod } from "../zod"
 
 export type Stack = (typeof Stack.stacks)[number]
 
@@ -11,15 +12,18 @@ export namespace Stack {
 		export const uk = ["uk-visa-tpl-marqeta", "uk-diners-clowd9"] as const
 		export const values = [...test, ...uk] as const
 		export const type = isly.string([...test, ...uk])
+		export const typeZod = zod.enum([...test, ...uk])
 	}
 	export type Decommissioned = (typeof Decommissioned.values)[number]
 	export namespace Decommissioned {
 		export const uk = ["uk-diners-dpg", "uk-mc-tpl-marqeta"] as const
 		export const values = [...uk] as const
 		export const type = isly.string(values)
+		export const typeZod = zod.enum(values)
 	}
 	export const stacks = [...Active.values, ...Decommissioned.values] as const
 	export const type = isly.string(stacks)
+	export const typeZod = zod.enum(stacks)
 	export function toRealm(stack: Stack): Realm {
 		return stack.split("-")[0] as Realm
 	}

package/Card/index.ts

@@ -5,6 +5,7 @@ import { Realm } from "../Realm"
 import { Report } from "../Report"
 import type { Rule } from "../Rule"
 import { type as ruleType } from "../Rule/type"
+import { zod } from "../zod"
 import { Changeable as CardChangeable } from "./Changeable"
 import { Creatable as CardCreatable } from "./Creatable"
 import { Expiry as CardExpiry } from "./Expiry"
@@ -75,6 +76,31 @@ export namespace Card {
 		meta: isly.fromIs("Card.Meta", CardMeta.is).optional(),
 		restricted: isly.object<Required<Card>["restricted"]>({ to: CardRestriction.type.optional() }).optional(),
 	})
+	export const typeZod = zod.object({
+		id: zod.string(),
+		number: zod.string().optional(),
+		created: zod.string().refine(isoly.DateTime.is),
+		organization: zod.string(),
+		realm: Realm.typeZod,
+		account: zod.string(),
+		preset: CardPreset.typeZod,
+		scheme: CardScheme.typeZod,
+		reference: zod.string(),
+		details: zod.object({
+			iin: zod.string(),
+			last4: zod.string(),
+			expiry: CardExpiry.typeZod,
+			holder: zod.string(),
+			token: zod.string().optional(),
+		}),
+		limit: Amount.typeZod,
+		spent: Amount.typeZod,
+		status: zod.enum(["active", "cancelled"]),
+		history: zod.array(CardOperation.typeZod),
+		rules: zod.array(zod.never()),
+		meta: CardMeta.typeZod.optional(),
+		restricted: zod.object({ to: CardRestriction.typeZod.optional() }).optional(),
+	})
 	const csvMap: Record<string, (card: Card) => string | number | undefined> = {
 		id: card => card.id,
 		created: card => readableDate(card.created),

package/Merchant/index.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 import { Category as MerchantCategory } from "./Category"
 
 export interface Merchant {
@@ -24,4 +25,14 @@ export namespace Merchant {
 		state: isly.string().optional(),
 		country: isly.string(),
 	})
+	export const typeZod = zod.object({
+		name: zod.string(),
+		id: zod.string(),
+		category: zod.string(),
+		address: zod.string(),
+		city: zod.string(),
+		zip: zod.string(),
+		state: zod.string().optional(),
+		country: zod.string(),
+	})
 }

package/Rail/Address/Card.ts

@@ -3,6 +3,7 @@ import { Acquirer } from "../../Acquirer"
 import { Card as ModelCard } from "../../Card"
 import { Merchant } from "../../Merchant"
 import type { Rule } from "../../Rule"
+import { zod } from "../../zod"
 
 export interface Card {
 	type: "card"
@@ -28,6 +29,13 @@ namespace CardCounterpart {
 		present: isly.boolean().optional(),
 		approvalCode: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("card"),
+		acquirer: Acquirer.typeZod,
+		merchant: Merchant.typeZod,
+		present: zod.boolean().optional(),
+		approvalCode: zod.string().optional(),
+	})
 }
 export namespace Card {
 	export const currencies = ["EUR", "GBP", "SEK", "USD"] as const
@@ -40,6 +48,15 @@ export namespace Card {
 		expiry: ModelCard.Expiry.type,
 		holder: isly.string(),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("card"),
+		scheme: ModelCard.Scheme.typeZod,
+		id: zod.string(),
+		iin: zod.string(),
+		last4: zod.string(),
+		expiry: ModelCard.Expiry.typeZod,
+		holder: zod.string(),
+	})
 
 	export function from(card: ModelCard | Rule.State.Card): Card {
 		return {

package/Rail/Address/Iban.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../../zod"
 
 export interface Iban {
 	type: "iban"
@@ -17,4 +18,11 @@ export namespace Iban {
 		institution: isly.string().optional(),
 		transactor: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("iban"),
+		iban: zod.string(),
+		holder: zod.string(),
+		institution: zod.string().optional(),
+		transactor: zod.string().optional(),
+	})
 }

package/Rail/Address/PaxGiro.ts

@@ -1,5 +1,6 @@
 import { cryptly } from "cryptly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 
 export interface PaxGiro {
 	type: "paxgiro"
@@ -8,4 +9,5 @@ export interface PaxGiro {
 export namespace PaxGiro {
 	export const currencies = ["EUR", "GBP", "SEK", "USD"] as const
 	export const type = isly.object<PaxGiro>({ type: isly.string("paxgiro"), identifier: isly.string() })
+	export const typeZod = zod.object({ type: zod.literal("paxgiro"), identifier: zod.string() })
 }

package/Rail/Address/Scan.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { Iban } from "./Iban"
 
 //SCAN: Sort Code Account Number
@@ -27,4 +28,11 @@ export namespace Scan {
 		holder: isly.string(),
 		institution: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("scan"),
+		sort: zod.string(),
+		account: zod.string(),
+		holder: zod.string(),
+		institution: zod.string().optional(),
+	})
 }

package/Rail/Address/index.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Realm } from "../../Realm"
+import { zod } from "../../zod"
 import { Card as AddressCard } from "./Card"
 import { Iban as AddressIban } from "./Iban"
 import { Internal as AddressInternal } from "./internal"
@@ -85,6 +86,14 @@ export namespace Address {
 		AddressPaxGiro.type,
 		AddressScan.type
 	)
+	export const typeZod = zod.union([
+		AddressCard.typeZod,
+		AddressCard.Counterpart.typeZod,
+		AddressIban.typeZod,
+		AddressInternal.typeZod,
+		AddressPaxGiro.typeZod,
+		AddressScan.typeZod,
+	])
 
 	export import PaxGiro = AddressPaxGiro
 	export import Iban = AddressIban