@pax2pay/model-banking 0.1.671 → 0.1.672

package/Account/Creatable.ts

@@ -18,5 +18,7 @@ export namespace Creatable {
 		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() })
+	export const typeZod = zod
+		.object({ name: zod.string(), location: Location.typeZod.optional() })
+		.meta({ id: "Account.Creatable" })
 }

package/Account/Details.ts

@@ -17,12 +17,14 @@ export namespace Details {
 		reference: isly.string().optional(),
 		addresses: Rail.Address.type.array(),
 	})
-	export const typeZod: zod.ZodType<Details> = zod.object({
-		supplier: Supplier.typeZod,
-		currencies: zodHelper.currency.array(),
-		reference: zod.string().optional(),
-		addresses: Rail.Address.typeZod.array(),
-	})
+	export const typeZod: zod.ZodType<Details> = zod
+		.object({
+			supplier: Supplier.typeZod,
+			currencies: zodHelper.currency.array(),
+			reference: zod.string().optional(),
+			addresses: Rail.Address.typeZod.array(),
+		})
+		.meta({ id: "Account.Details" })
 	export interface Creatable {
 		supplier: Supplier
 		currency: isoly.Currency
@@ -32,9 +34,8 @@ export namespace Details {
 			supplier: Supplier.type,
 			currency: isly.string(isoly.Currency.values),
 		})
-		export const typeZod: zod.ZodType<Creatable> = zod.object({
-			supplier: Supplier.typeZod,
-			currency: zodHelper.currency,
-		})
+		export const typeZod: zod.ZodType<Creatable> = zod
+			.object({ supplier: Supplier.typeZod, currency: zodHelper.currency })
+			.meta({ id: "Account.Details.Creatable" })
 	}
 }

package/Account/Type.ts

@@ -5,5 +5,5 @@ export type Type = (typeof Type.values)[number]
 export namespace Type {
 	export const values = ["own funds", "emoney"] as const
 	export const type = isly.string<Type>(values)
-	export const typeZod = zod.enum(values)
+	export const typeZod = zod.enum(values).meta({ id: "Account.Type" })
 }

package/Account/index.ts

@@ -43,18 +43,20 @@ 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: Rail.Address.typeZod.array(),
-		details: Details.typeZod.optional(),
-		charges: AccountCharge.typeZod.optional(),
-		rules: zod.any().array().optional(),
-		status: AccountStatus.typeZod,
-		type: Type.typeZod,
-	})
+	export const typeZod = Creatable.typeZod
+		.extend({
+			id: zod.string(),
+			created: zod.string().refine(isoly.DateTime.is),
+			organization: zod.string(),
+			balances: Balances.typeZod,
+			rails: Rail.Address.typeZod.array(),
+			details: Details.typeZod.optional(),
+			charges: AccountCharge.typeZod.optional(),
+			rules: zod.any().array().optional(),
+			status: AccountStatus.typeZod,
+			type: Type.typeZod,
+		})
+		.meta({ id: "Account" })
 	export function isIdentifier(value: cryptly.Identifier | any): value is cryptly.Identifier {
 		return cryptly.Identifier.is(value, 8)
 	}

package/Amount.ts

@@ -4,11 +4,10 @@ import { Amounts } from "./Amounts"
 import { zod, zodHelper } from "./zod"
 
 export type Amount = [isoly.Currency, number]
-
 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.values), isly.number())
-	export const typeZod: zod.ZodType<Amount> = zod.tuple([zodHelper.currency, zod.number()])
+	export const typeZod: zod.ZodType<Amount> = zod.tuple([zodHelper.currency, zod.number()]).meta({ id: "Amount" })
 }

package/Amounts.ts

@@ -3,7 +3,6 @@ import { isly } from "isly"
 import { zod, zodHelper } from "./zod"
 
 export type Amounts = Partial<Record<isoly.Currency, number>>
-
 export namespace Amounts {
 	export function add(addendee: Amounts, addend: Amounts): Amounts {
 		return (Object.entries(addend) as [isoly.Currency, number][]).reduce(
@@ -20,5 +19,7 @@ export namespace Amounts {
 		)
 	}
 	export const type = isly.record<Amounts>(isly.string(isoly.Currency.values), isly.number())
-	export const typeZod: zod.ZodType<Amounts> = zod.partialRecord(zodHelper.currency, zod.number())
+	export const typeZod: zod.ZodType<Amounts> = zod
+		.partialRecord(zodHelper.currency, zod.number())
+		.meta({ id: "Amounts" })
 }

package/Balance.ts

@@ -1,7 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import zod from "zod"
 import { Amount } from "./Amount"
-import { zod } from "./zod"
 
 export type Balance = { available?: number; reserved?: Balance.Reserved }
 export namespace Balance {
@@ -12,14 +12,18 @@ export namespace Balance {
 		export const typeZod = zod.enum(values)
 	}
 	export type Reserved = Partial<Record<Balance.Reserve, number>>
+	export namespace Reserved {
+		export const typeZod: zod.ZodType<Reserved> = zod
+			.partialRecord(Reserve.typeZod, zod.number())
+			.meta({ id: "Balance.Reserved" })
+	}
 	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(),
+		reserved: isly.record<Reserved>(Reserve.type, isly.number().optional()).optional(),
 	})
+	export const typeZod = zod
+		.object({ available: zod.number().optional(), reserved: Reserved.typeZod.optional() })
+		.meta({ id: "Balance" })
 	export type Legacy = Partial<Record<Legacy.Entry, number>>
 	export namespace Legacy {
 		export type Entry = (typeof Entry.values)[number]
@@ -38,12 +42,14 @@ export namespace Balance {
 	export type Extended = Balance & Legacy
 	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 const typeZod = Balance.typeZod
+			.extend({
+				actual: zod.number().optional(),
+				incomingReserved: zod.number().optional(),
+				outgoingReserved: zod.number().optional(),
+				bufferReserved: zod.number().optional(),
+			})
+			.meta({ id: "Balance.Extended" })
 	}
 	export function update(currency: isoly.Currency, balance: MaybeLegacy): Extended {
 		const result: Extended = { ...balance }

package/Balances.ts

@@ -5,11 +5,12 @@ import { Balance as BalancesBalance } from "./Balance"
 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(zodHelper.currency, Balances.Balance.Extended.typeZod)
+	export const typeZod: zod.ZodType<Balances> = zod
+		.partialRecord(zodHelper.currency, Balances.Balance.Extended.typeZod)
+		.meta({ id: "Balances" })
 	export function update(balances: Balances): Balances {
 		const result: Balances = {}
 		for (const [currency, balance] of Object.entries(balances)) {

package/Card/Creatable.ts

@@ -32,14 +32,16 @@ export namespace Creatable {
 		key: isly.string().optional(),
 		restricted: isly.object<Required<Creatable>["restricted"]>({ to: Restriction.type.optional() }).optional(),
 	})
-	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,
-		meta: Meta.typeZod.optional(),
-		key: zod.string().optional(),
-		restricted: zod.object({ to: Restriction.typeZod.optional() }).optional(),
-	})
+	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,
+			meta: Meta.typeZod.optional(),
+			key: zod.string().optional(),
+			restricted: zod.object({ to: Restriction.typeZod.optional() }).optional(),
+		})
+		.meta({ id: "Card.Creatable" })
 }

package/Card/Preset.ts

@@ -26,7 +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 typeZod = zod.enum(names).meta({ id: "Card.Preset" })
 	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

@@ -9,7 +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 const typeZod = zod.enum(values).meta({ id: "Card.Restriction.Merchant" })
 	export function check(merchant: Merchant, counterpart: Rail.Address.Card.Counterpart): boolean {
 		const attribute: Attribute = merchants[merchant]
 		let result: boolean

package/Card/Restriction/index.ts

@@ -9,7 +9,9 @@ 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 const typeZod: zod.ZodType<Restriction> = zod
+		.object({ merchants: Merchant.typeZod.array().optional() })
+		.meta({ id: "Card.Restriction" })
 	export function check(
 		restrictions: Restriction,
 		transaction: Transaction.Creatable.CardTransaction | Transaction.PreTransaction.Authorization

package/Card/Scheme.ts

@@ -5,5 +5,5 @@ 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)
+	export const typeZod = zod.enum(schemes).meta({ id: "Card.Scheme" })
 }

package/Card/index.ts

@@ -76,31 +76,33 @@ 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.ZodType<Card> = 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: CardOperation.typeZod.array(),
-		rules: zod.any().array(),
-		meta: CardMeta.typeZod.optional(),
-		restricted: zod.object({ to: CardRestriction.typeZod.optional() }).optional(),
-	})
+	export const typeZod: zod.ZodType<Card> = 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: CardOperation.typeZod.array(),
+			rules: zod.any().array(),
+			meta: CardMeta.typeZod.optional(),
+			restricted: zod.object({ to: CardRestriction.typeZod.optional() }).optional(),
+		})
+		.meta({ id: "Card" })
 	const csvMap: Record<string, (card: Card) => string | number | undefined> = {
 		id: card => card.id,
 		created: card => readableDate(card.created),

package/Operation/Change.ts

@@ -18,12 +18,14 @@ export namespace Change {
 		status: Status.type,
 		result: isly.number().optional(),
 	})
-	export const typeZod = zod.object({
-		type: zod.enum(operand),
-		amount: zod.number(),
-		status: Status.typeZod,
-		result: zod.number().optional(),
-	})
+	export const typeZod = zod
+		.object({
+			type: zod.enum(operand),
+			amount: zod.number(),
+			status: Status.typeZod,
+			result: zod.number().optional(),
+		})
+		.meta({ id: "Operation.Change" })
 	export namespace Add {
 		export const type = Change.type.extend<Change<"add">>({
 			type: isly.string("add"),

package/Operation/Changes.ts

@@ -48,7 +48,7 @@ export namespace Changes {
 	export type Sum = Partial<Record<Changes.Entry.Balance, number>>
 	export type MaybeLegacy = Changes | Legacy
 	export const type = isly.record<Changes>(isly.string(), Change.type)
-	export const typeZod = zod.record(zod.string(), Change.typeZod)
+	export const typeZod = zod.record(zod.string(), Change.typeZod).meta({ id: "Operation.Changes" })
 	export type Legacy = Partial<Record<AccountBalance.Legacy.Entry, Change>>
 	export namespace Legacy {
 		export const type = isly.record<Legacy>(isly.string(), Change.type)

package/Operation/Creatable.ts

@@ -38,13 +38,15 @@ export namespace Creatable {
 		type: isly.string(types),
 		counterbalance: isly.string().optional(),
 	})
-	export const typeZod = zod.object({
-		account: zod.string(),
-		currency: zodHelper.currency,
-		changes: Changes.typeZod,
-		type: zod.enum(types),
-		counterbalance: zod.string().optional(),
-	})
+	export const typeZod = zod
+		.object({
+			account: zod.string(),
+			currency: zodHelper.currency,
+			changes: Changes.typeZod,
+			type: zod.enum(types),
+			counterbalance: zod.string().optional(),
+		})
+		.meta({ id: "Operation.Creatable" })
 	export function fromRefund(account: string, settlement: string, entry: Settlement.Entry.Creatable.Refund): Creatable {
 		// The Entry.Refund.Creatable has negative amount and fee
 		// The operation amounts should always be positive

package/Operation/Status.ts

@@ -6,5 +6,5 @@ export type Status = (typeof Status.values)[number]
 export namespace Status {
 	export const values = ["pending", "success", "failed"] as const
 	export const type = isly.string(values)
-	export const typeZod = zod.enum(values)
+	export const typeZod = zod.enum(values).meta({ id: "Operation.Status" })
 }

package/Operation/index.ts

@@ -35,13 +35,15 @@ export namespace Operation {
 	export import Creatable = OperationCreatable
 	export import Changes = OperationChanges
 	export import Change = OperationChange
-	export const typeZod = Creatable.typeZod.extend({
-		transaction: zod.string(),
-		counter: zod.number(),
-		created: zod.string().refine(isoly.DateTime.is),
-		signature: zod.string().optional(),
-		previous: zod.string().optional(),
-	})
+	export const typeZod = Creatable.typeZod
+		.extend({
+			transaction: zod.string(),
+			counter: zod.number(),
+			created: zod.string().refine(isoly.DateTime.is),
+			signature: zod.string().optional(),
+			previous: zod.string().optional(),
+		})
+		.meta({ id: "Operation" })
 	export const type = OperationCreatable.type.extend<Operation>({
 		transaction: isly.string(),
 		counter: isly.number(),

package/Organization/Changeable.ts

@@ -11,8 +11,7 @@ export namespace Changeable {
 		name: isly.string().optional(),
 		contact: Contact.Creatable.type.optional(),
 	})
-	export const typeZod = zod.object({
-		name: zod.string().optional(),
-		contact: Contact.Creatable.typeZod.optional(),
-	})
+	export const typeZod = zod
+		.object({ name: zod.string().optional(), contact: Contact.Creatable.typeZod.optional() })
+		.meta({ id: "Organization.Changeable" })
 }

package/Organization/Contact/Address/Default.ts

@@ -19,12 +19,14 @@ export namespace Default {
 		street: isly.string(),
 		zipCode: isly.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(),
-		zipCode: zod.string(),
-		street: 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(),
+			zipCode: zod.string(),
+			street: zod.string(),
+		})
+		.meta({ id: "Organization.Contact.Address.Default" })
 }

package/Organization/Contact/Address/GB.ts

@@ -18,11 +18,13 @@ export namespace GB {
 		building: isly.string(),
 		zipCode: isly.string(),
 	})
-	export const typeZod: zod.ZodType<GB> = zod.object({
-		countryCode: zod.literal("GB"),
-		city: zod.string(),
-		street: zod.string(),
-		building: zod.string(),
-		zipCode: zod.string(),
-	})
+	export const typeZod: zod.ZodType<GB> = zod
+		.object({
+			countryCode: zod.literal("GB"),
+			city: zod.string(),
+			street: zod.string(),
+			building: zod.string(),
+			zipCode: zod.string(),
+		})
+		.meta({ id: "Organization.Contact.Address.GB" })
 }

package/Organization/Contact/Address/SE.ts

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

package/Organization/Contact/Address/index.ts

@@ -5,8 +5,9 @@ import { GB } from "./GB"
 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.ZodType<Address> = zod.union([GB.typeZod, SE.typeZod, Default.typeZod])
+	export const typeZod: zod.ZodType<Address> = zod
+		.union([GB.typeZod, SE.typeZod, Default.typeZod])
+		.meta({ id: "Organization.Contact.Address" })
 }

package/Organization/Contact/Addresses.ts

@@ -15,10 +15,12 @@ export namespace Addresses {
 		delivery: Address.type.optional(),
 		visit: Address.type.optional(),
 	})
-	export const typeZod: zod.ZodType<Addresses> = zod.object({
-		primary: Address.typeZod,
-		billing: Address.typeZod.optional(),
-		delivery: Address.typeZod.optional(),
-		visit: Address.typeZod.optional(),
-	})
+	export const typeZod: zod.ZodType<Addresses> = zod
+		.object({
+			primary: Address.typeZod,
+			billing: Address.typeZod.optional(),
+			delivery: Address.typeZod.optional(),
+			visit: Address.typeZod.optional(),
+		})
+		.meta({ id: "Organization.Contact.Addresses" })
 }

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

@@ -19,11 +19,13 @@ export namespace Creatable {
 		contact: Contact.Creatable.type.optional(),
 		fx: Fx.type.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(),
-	})
+	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,18 +40,20 @@ export namespace Organization {
 		fx: OrganizationFx.type.optional(),
 		type: Type.type,
 	})
-	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,
-	})
+	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: [], 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