@pax2pay/model-banking 0.1.670 → 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

@@ -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,12 +17,14 @@ 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 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.object({
-			supplier: Supplier.typeZod,
-			currency: zod.enum(isoly.Currency.values),
-		})
+		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

@@ -39,22 +39,24 @@ 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,
 	})
-	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 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/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,14 +1,13 @@
 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]
-
 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.tuple([zod.enum(isoly.Currency.values), zod.number()])
+	export const typeZod: zod.ZodType<Amount> = zod.tuple([zodHelper.currency, zod.number()]).meta({ id: "Amount" })
 }

package/Amounts.ts

@@ -1,9 +1,8 @@
 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>>
-
 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(zod.enum(isoly.Currency.values), 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

@@ -2,14 +2,15 @@ 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.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

@@ -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,20 +28,20 @@ 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({
-		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(),
-	})
+	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

@@ -71,36 +71,38 @@ 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({
-		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(),
-	})
+	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/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/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

@@ -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 {
@@ -38,13 +38,15 @@ export namespace Creatable {
 		type: isly.string(types),
 		counterbalance: isly.string().optional(),
 	})
-	export const typeZod = zod.object({
-		account: zod.string(),
-		currency: zod.enum(isoly.Currency.values),
-		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/{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,12 +19,14 @@ export namespace Default {
 		street: isly.string(),
 		zipCode: isly.string(),
 	})
-	export const typeZod = zod.object({
-		countryCode: zod.string(),
-		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

@@ -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,11 +18,13 @@ export namespace GB {
 		building: isly.string(),
 		zipCode: isly.string(),
 	})
-	export const typeZod = 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.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

@@ -1,12 +1,13 @@
 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])
+		.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.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" })
 }