@pax2pay/model-banking 0.1.657 → 0.1.658

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/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,12 +9,17 @@ 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]

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.typeZod)
 	export function update(balances: Balances): Balances {
 		const result: Balances = {}
 		for (const [currency, balance] of Object.entries(balances)) {

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/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/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/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

package/Rail/Address/internal.ts

@@ -2,6 +2,7 @@ import { cryptly } from "cryptly"
 import { isly } from "isly"
 import { Operation } from "../../Operation"
 import { Realm } from "../../Realm"
+import { zod } from "../../zod"
 
 export interface Internal {
 	type: "internal"
@@ -17,6 +18,12 @@ export namespace Internal {
 		identifier: isly.union(isly.fromIs("Identifier", cryptly.Identifier.is), Operation.Changes.Entry.type),
 		organization: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("internal"),
+		name: zod.string().optional(),
+		identifier: zod.string(),
+		organization: zod.string().optional(),
+	})
 
 	export function toLink(internal: Internal, realm: Realm): string {
 		return `${realm}-internal-${internal.identifier}`

package/Supplier/index.ts

@@ -1,11 +1,13 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Realm } from "../Realm"
+import { zod } from "../zod"
 
 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 decommissioned = ["clearbank"] as const
 	export type Decommissioned = (typeof decommissioned)[number]
 	export function isDecommissioned(supplier: Supplier | any): supplier is Decommissioned {

package/dist/cjs/Account/Charge/Fx/index.d.ts

@@ -6,5 +6,26 @@ import { Preset } from "../Preset";
 export type Fx = Preset;
 export declare namespace Fx {
     const type: import("isly/dist/cjs/Type").Type<Preset>;
+    const typeZod: import("zod").ZodIntersection<import("zod").ZodRecord<import("zod").ZodEnum<{
+        default: "default";
+        "p2p-diners-175": "p2p-diners-175";
+        "p2p-diners-200": "p2p-diners-200";
+        "p2p-mc-200": "p2p-mc-200";
+        "p2p-visa-bid-115": "p2p-visa-bid-115";
+        "p2p-visa-bp-140": "p2p-visa-bp-140";
+        "p2p-visa-cdd-185": "p2p-visa-cdd-185";
+        "p2p-visa-idx-140": "p2p-visa-idx-140";
+        "p2p-visa-idx-160": "p2p-visa-idx-160";
+        "p2p-visa-idx-200": "p2p-visa-idx-200";
+        "p2p-diners-tsa-175": "p2p-diners-tsa-175";
+        "test-pg-150": "test-pg-150";
+        "test-pg-200": "test-pg-200";
+        "test-ta-mc-200": "test-ta-mc-200";
+        "test-ta-pg-200": "test-ta-pg-200";
+        "test-ta-pg-bc-200": "test-ta-pg-bc-200";
+        "test-diners-175": "test-diners-175";
+    }> & import("zod/v4/core/schemas.cjs").$partial, import("zod").ZodNumber>, import("zod").ZodObject<{
+        default: import("zod").ZodNumber;
+    }, import("zod/v4/core/schemas.cjs").$strip>>;
     function evaluate(charge: Fx, currency: isoly.Currency, amount: number, preset?: Card.Preset, exchange?: Exchange): Amount.Charge.Fx | undefined;
 }

package/dist/cjs/Account/Charge/Fx/index.js

@@ -6,6 +6,7 @@ const Preset_1 = require("../Preset");
 var Fx;
 (function (Fx) {
     Fx.type = Preset_1.Preset.type;
+    Fx.typeZod = Preset_1.Preset.typeZod;
     function evaluate(charge, currency, amount, preset, exchange) {
         let result;
         const chargePreset = preset && charge[preset] ? preset : "default";

package/dist/cjs/Account/Charge/Fx/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Fx/index.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAI7B,sCAAkC;AAIlC,IAAiB,EAAE,CAqBlB;AArBD,WAAiB,EAAE;IACL,OAAI,GAAG,eAAM,CAAC,IAAI,CAAA;IAC/B,SAAgB,QAAQ,CACvB,MAAU,EACV,QAAwB,EACxB,MAAc,EACd,MAAoB,EACpB,QAAmB;QAEnB,IAAI,MAAoC,CAAA;QACxC,MAAM,YAAY,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAA;QAClE,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC5C,IAAI,QAAQ,EAAE,CAAC;YACd,MAAM,GAAG;gBACR,MAAM,EAAE,YAAY;gBACpB,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC;aAC9D,CAAA;QACF,CAAC;QACD,OAAO,MAAM,CAAA;IACd,CAAC;IAlBe,WAAQ,WAkBvB,CAAA;AACF,CAAC,EArBgB,EAAE,kBAAF,EAAE,QAqBlB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Fx/index.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAI7B,sCAAkC;AAIlC,IAAiB,EAAE,CAsBlB;AAtBD,WAAiB,EAAE;IACL,OAAI,GAAG,eAAM,CAAC,IAAI,CAAA;IAClB,UAAO,GAAG,eAAM,CAAC,OAAO,CAAA;IACrC,SAAgB,QAAQ,CACvB,MAAU,EACV,QAAwB,EACxB,MAAc,EACd,MAAoB,EACpB,QAAmB;QAEnB,IAAI,MAAoC,CAAA;QACxC,MAAM,YAAY,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAA;QAClE,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC5C,IAAI,QAAQ,EAAE,CAAC;YACd,MAAM,GAAG;gBACR,MAAM,EAAE,YAAY;gBACpB,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC;aAC9D,CAAA;QACF,CAAC;QACD,OAAO,MAAM,CAAA;IACd,CAAC;IAlBe,WAAQ,WAkBvB,CAAA;AACF,CAAC,EAtBgB,EAAE,kBAAF,EAAE,QAsBlB"}