@pax2pay/model-banking 0.1.663 → 0.1.665

package/Amounts.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "./zod"
 
 export type Amounts = Partial<Record<isoly.Currency, number>>
 
@@ -19,4 +20,5 @@ 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())
 }

package/Merchant/Category.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export type Category = string
 
@@ -7,4 +8,5 @@ export namespace Category {
 		"Merchant.Category",
 		(value: any): value is Category => typeof value === "string" && /^\d{4}$/.test(value)
 	)
+	export const typeZod: zod.ZodType<Category> = zod.string().regex(/^\d{4}$/)
 }

package/Merchant/index.ts

@@ -33,6 +33,6 @@ export namespace Merchant {
 		city: zod.string(),
 		zip: zod.string(),
 		state: zod.string().optional(),
-		country: zod.string(),
+		country: zod.enum(isoly.CountryCode.Alpha2.values),
 	})
 }

package/Settlement/Amount.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export type Amount = {
 	net: number
@@ -12,6 +13,10 @@ 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 function sum(currency: isoly.Currency, amount: Amount | undefined): number {
 		return isoly.Currency.add(currency, amount?.net ?? 0, amount?.fee.other ?? 0)
 	}

package/Settlement/Batch.ts

@@ -1,6 +1,8 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export type Batch = string
 export namespace Batch {
 	export const type = isly.string<Batch>()
+	export const typeZod: zod.ZodType<Batch> = zod.string()
 }

package/Settlement/Creatable.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Card } from "../Card"
+import { zod } from "../zod"
 import { Batch } from "./Batch"
 import { Totals } from "./Totals"
 
@@ -19,4 +20,11 @@ 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>
 }

package/Settlement/Entry/Creatable.ts

@@ -3,6 +3,7 @@ import { Acquirer } from "../../Acquirer"
 import { Amount } from "../../Amount"
 import { Merchant } from "../../Merchant"
 import { Exchange } from "../../Transaction/Exchange"
+import { zod } from "../../zod"
 import { Batch } from "../Batch"
 import { Fee } from "../Fee"
 import { Identifier as SettlementIdentifier } from "../Identifier"
@@ -40,23 +41,41 @@ export namespace Creatable {
 			settlement: SettlementIdentifier.type,
 			exchange: Exchange.type.optional(),
 		})
+		export const typeZod = zod.object({
+			card: zod.string(),
+			transaction: zod.string().optional(),
+			transactionReference: zod.string().optional(),
+			account: zod.string(),
+			approvalCode: zod.string(),
+			merchant: Merchant.typeZod,
+			acquirer: Acquirer.typeZod,
+			reference: zod.string(),
+			batch: Batch.typeZod,
+			fee: Fee.typeZod,
+			amount: Amount.typeZod,
+			settlement: SettlementIdentifier.typeZod,
+			exchange: Exchange.typeZod.optional(),
+		})
 	}
 	export interface Capture extends Base {
 		type: "capture"
 	}
 	export namespace Capture {
 		export const type = Base.type.extend<Capture>({ type: isly.string("capture") })
+		export const typeZod: zod.ZodType<Capture> = Base.typeZod.extend({ type: zod.literal("capture") })
 	}
 	export interface Refund extends Base {
 		type: "refund"
 	}
 	export namespace Refund {
 		export const type = Base.type.extend<Refund>({ type: isly.string("refund") })
+		export const typeZod: zod.ZodType<Refund> = Base.typeZod.extend({ type: zod.literal("refund") })
 	}
 	export type Known = Capture | Refund
 
 	export namespace Known {
 		export const type = isly.union(Capture.type, Refund.type)
+		export const typeZod: zod.ZodType<Known> = zod.union([Capture.typeZod, Refund.typeZod])
 	}
 	export interface Unknown extends Partial<Base> {
 		type: "unknown"
@@ -70,6 +89,11 @@ export namespace Creatable {
 			type: isly.string("unknown"),
 			data: isly.record<Record<string, unknown>>(isly.string(), isly.any()),
 		})
+		export const typeZod: zod.ZodType<Unknown> = Base.typeZod.partial().extend({
+			type: zod.literal("unknown"),
+			data: zod.record(zod.string(), zod.any()),
+		})
 	}
 	export const type = isly.union(Known.type, Unknown.type)
+	export const typeZod: zod.ZodType<Creatable> = zod.union([Known.typeZod, Unknown.typeZod])
 }

package/Settlement/Entry/Failed.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { Creatable } from "./Creatable"
 
 export type Failed = Creatable & {
@@ -24,4 +25,12 @@ export namespace Failed {
 			created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 		})
 	)
+	export const typeZod = zod.intersection(
+		Creatable.typeZod,
+		zod.object({
+			status: zod.literal("failed"),
+			reason: zod.string(),
+			created: zod.string().refine(isoly.DateTime.is),
+		})
+	)
 }

package/Settlement/Entry/Succeeded.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../../Rail"
+import { zod } from "../../zod"
 import { Creatable } from "./Creatable"
 
 export interface Succeeded extends Omit<Creatable.Known, "transaction" | "card"> {
@@ -23,4 +24,15 @@ export namespace Succeeded {
 			}),
 			created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 		})
+	export const typeZod: zod.ZodType<Succeeded> = Creatable.Base.typeZod.omit({ card: true, transaction: true }).extend({
+		type: zod.enum(["capture", "refund"]),
+		status: zod.literal("succeeded"),
+		card: Rail.Address.Card.typeZod,
+		transaction: zod.object({
+			id: zod.string(),
+			posted: zod.string().refine(isoly.DateTime.is),
+			description: zod.string(),
+		}),
+		created: zod.string().refine(isoly.DateTime.is),
+	})
 }

package/Settlement/Entry/Summary.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../../zod"
 
 export interface Summary {
 	count: number
@@ -10,4 +11,8 @@ export namespace Summary {
 		count: isly.number(),
 		failed: isly.object<{ count: number }>({ count: isly.number() }).optional(),
 	})
+	export const typeZod: zod.ZodType<Summary> = zod.object({
+		count: zod.number(),
+		failed: zod.object({ count: zod.number() }).optional(),
+	})
 }

package/Settlement/Entry/index.ts

@@ -8,7 +8,7 @@ import { Failed as EntryFailed } from "./Failed"
 import { fromCreatable } from "./fromCreatable"
 import { Succeeded as EntrySucceeded } from "./Succeeded"
 import { Summary as EntrySummary } from "./Summary"
-import { type as entryType } from "./type"
+import { type as entryType, typeZod as entryTypeZod } from "./type"
 
 export type Entry = EntrySucceeded | EntryFailed
 export namespace Entry {
@@ -23,6 +23,7 @@ export namespace Entry {
 	export import Succeeded = EntrySucceeded
 	export import Summary = EntrySummary
 	export const type = entryType
+	export const typeZod = entryTypeZod
 	export const from = fromCreatable
 	export function charge(
 		counterpart: Rail.Address.Card.Counterpart,

package/Settlement/Entry/type.ts

@@ -1,6 +1,8 @@
 import { isly } from "isly"
+import { zod } from "../../zod"
 import type { Entry } from "."
 import { Failed } from "./Failed"
 import { Succeeded } from "./Succeeded"
 
 export const type = isly.union<Entry, Succeeded, Failed>(Succeeded.type, Failed.type)
+export const typeZod: zod.ZodType<Entry> = zod.union([Succeeded.typeZod, Failed.typeZod])

package/Settlement/Fee.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Amounts } from "../Amounts"
+import { zod } from "../zod"
 
 export interface Fee {
 	other: Amounts
@@ -9,4 +10,5 @@ export namespace Fee {
 		return { other: Amounts.add(addendee.other, addend.other) }
 	}
 	export const type = isly.object<Fee>({ other: Amounts.type })
+	export const typeZod: zod.ZodType<Fee> = zod.object({ other: Amounts.typeZod })
 }

package/Settlement/Identifier.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Card } from "../Card"
+import { zod } from "../zod"
 
 //(date without dashes)(stack.Character)(single digit number representing batch)
 //20200102a3
@@ -16,6 +17,7 @@ export namespace Identifier {
 		return Card.Stack.Character.toStack(getCharacter(identifier))
 	}
 	export const type = isly.string()
+	export const typeZod: zod.ZodType<Identifier> = zod.string()
 	export function create(date: isoly.Date, stack: Card.Stack, order: number): Identifier {
 		return date.replace(/-/g, "") + Card.Stack.Character.from(stack) + order
 	}

package/Settlement/Status.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export interface Status {
 	collected: Status.Values
@@ -12,4 +13,8 @@ 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),
+	})
 }

package/Settlement/Total.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Supplier } from "../Supplier"
+import { zod } from "../zod"
 import { Amount } from "./Amount"
 
 export interface Total {
@@ -19,8 +20,16 @@ export namespace Total {
 				fee: isly.string().optional(),
 				supplier: Supplier.type.optional(),
 			})
+			export const typeZod: zod.ZodType<Transaction> = zod.object({
+				net: zod.string(),
+				fee: zod.string().optional(),
+				supplier: Supplier.typeZod.optional(),
+			})
 		}
 		export const type = isly.object<Collected>({ transactions: isly.union(Transaction.type, Transaction.type.array()) })
+		export const typeZod: zod.ZodType<Collected> = zod.object({
+			transactions: zod.union([Transaction.typeZod, zod.array(Transaction.typeZod)]),
+		})
 	}
 	export type Settled = { net: number; transactions: string[]; fee?: string }
 	export const Settled = isly.object<Settled>({
@@ -28,12 +37,23 @@ export namespace Total {
 		transactions: isly.string().array(),
 		fee: isly.string().optional(),
 	})
+	export const SettledZod: zod.ZodType<Settled> = zod.object({
+		net: zod.number(),
+		transactions: zod.array(zod.string()),
+		fee: zod.string().optional(),
+	})
 	export const type = isly.object<Total>({
 		expected: Amount.type,
 		outcome: Amount.type.optional(),
 		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 function create(): Total {
 		return { expected: { net: 0, fee: { other: 0 } } }
 	}

package/Settlement/Totals.ts

@@ -1,11 +1,13 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } 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 function addEntry(totals: Totals, entry: Entry): Totals {
 		const result = { ...totals }
 		if (entry.status == "succeeded" && (entry.type == "capture" || entry.type == "refund")) {

package/Settlement/index.ts

@@ -2,13 +2,14 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amounts } from "../Amounts"
 import { Settlement as SettlementWarning } from "../Warning/Settlement"
+import { zod } from "../zod"
 import { Amount as SettlementAmount } from "./Amount"
 import { Batch as SettlementBatch } from "./Batch"
 import { Creatable as SettlementCreatable } from "./Creatable"
 import { Entry as SettlementEntry } from "./Entry"
 import { Fee as SettlementFee } from "./Fee"
 import { Identifier as SettlementIdentifier } from "./Identifier"
-import { Status } from "./Status"
+import { Status as SettlementStatus } from "./Status"
 import { Total as SettlementTotal } from "./Total"
 import { Totals as SettlementTotals } from "./Totals"
 
@@ -16,7 +17,7 @@ export interface Settlement extends Settlement.Creatable {
 	id: SettlementIdentifier | string // string is deprecated and there for legacy reasons
 	by?: string
 	created: isoly.DateTime
-	status: Status
+	status: SettlementStatus
 	entries: Settlement.Entry.Summary
 	warnings?: Settlement.Warning[]
 }
@@ -25,6 +26,7 @@ export namespace Settlement {
 	export import Total = SettlementTotal
 	export import Totals = SettlementTotals
 	export import Amount = SettlementAmount
+	export import Status = SettlementStatus
 	export import Fee = SettlementFee
 	export import Creatable = SettlementCreatable
 	export import Entry = SettlementEntry
@@ -73,4 +75,12 @@ 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(),
+	})
 }

package/Warning/Base.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 import { Issue } from "./Issue"
 
 export interface Base {
@@ -17,6 +18,7 @@ export namespace Base {
 	export namespace Severity {
 		export const values = ["low", "medium", "high"] as const
 		export const type = isly.string<Severity>(values)
+		export const typeZod: zod.ZodType<Severity> = zod.enum(values)
 	}
 	export const type = isly.object<Base>({
 		type: isly.string(),
@@ -27,4 +29,13 @@ export namespace Base {
 		issue: Issue.type.optional(),
 		description: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		type: zod.string(),
+		severity: Severity.typeZod.optional(),
+		resource: zod.string(),
+		value: zod.number().optional(),
+		date: zod.string(),
+		issue: Issue.typeZod.optional(),
+		description: zod.string().optional(),
+	}) satisfies zod.ZodType<Base>
 }

package/Warning/Issue.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export interface Issue {
 	link: string
@@ -10,6 +11,10 @@ export namespace Issue {
 		link: isly.string(),
 		status: isly.string(["closed", "open"]),
 	})
+	export const typeZod: zod.ZodType<Issue> = zod.object({
+		link: zod.string(),
+		status: zod.enum(["closed", "open"]),
+	})
 	export interface Creatable {
 		type: string
 		currency: isoly.Currency
@@ -23,5 +28,11 @@ export namespace Issue {
 			resource: isly.string().optional(),
 			issue: Issue.type,
 		})
+		export const typeZod: zod.ZodType<Creatable> = zod.object({
+			type: zod.string(),
+			currency: zod.enum(isoly.Currency.values),
+			resource: zod.string().optional(),
+			issue: Issue.typeZod,
+		})
 	}
 }

package/Warning/Settlement/MissingFile.ts

@@ -2,6 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Identifier } from "../../Settlement/Identifier"
 import { Totals } from "../../Settlement/Totals"
+import { zod } from "../../zod"
 import { Base } from "../Base"
 
 export interface MissingFile extends Base {
@@ -18,6 +19,12 @@ export namespace MissingFile {
 		cycle: isly.string().optional(),
 		totals: Totals.type.optional(),
 	})
+	export const typeZod: zod.ZodType<MissingFile> = Base.typeZod.extend({
+		type: zod.literal("missing-file"),
+		resource: Identifier.typeZod,
+		cycle: zod.string().optional(),
+		totals: Totals.typeZod.optional(),
+	})
 	export function create(id: string, cycle: string, date: isoly.Date): MissingFile {
 		return {
 			type: "missing-file",

package/Warning/Settlement/NegativeAmount.ts

@@ -3,6 +3,7 @@ import { isly } from "isly"
 import { typedly } from "typedly"
 import { Identifier } from "../../Settlement/Identifier"
 import { Totals } from "../../Settlement/Totals"
+import { zod } from "../../zod"
 import { Base } from "../Base"
 
 export interface NegativeAmount extends Base {
@@ -19,6 +20,12 @@ export namespace NegativeAmount {
 		value: isly.number(),
 		currency: isly.fromIs("currency", isoly.Currency.is),
 	})
+	export const typeZod: zod.ZodType<NegativeAmount> = Base.typeZod.extend({
+		type: zod.literal("negative-amount"),
+		resource: Identifier.typeZod,
+		value: zod.number(),
+		currency: zod.enum(isoly.Currency.values),
+	})
 	export function create(resource: Identifier, totals: Totals): NegativeAmount[] {
 		const warnings: NegativeAmount[] = []
 		typedly.Object.entries(totals).forEach(

package/Warning/Settlement/UnknownEntry.ts

@@ -5,6 +5,7 @@ import { Authorization } from "../../Authorization"
 import { Entry } from "../../Settlement/Entry"
 import { Identifier } from "../../Settlement/Identifier"
 import { Transaction } from "../../Transaction"
+import { zod } from "../../zod"
 import { Base } from "../Base"
 
 export interface UnknownEntry extends Base {
@@ -21,6 +22,12 @@ export namespace UnknownEntry {
 		authorization: isly.fromIs("Authorization.id", cryptly.Identifier.is).optional(),
 		transaction: isly.string().optional(),
 	})
+	export const typeZod: zod.ZodType<UnknownEntry> = Base.typeZod.extend({
+		type: zod.literal("unknown-entry"),
+		resource: Identifier.typeZod,
+		authorization: zod.string().refine(cryptly.Identifier.is).optional(),
+		transaction: zod.string().optional(),
+	})
 	export function create(entry: Extract<Entry.Failed, { type: "unknown" }>, resource: Identifier): UnknownEntry {
 		return {
 			type: "unknown-entry",

package/Warning/Settlement/index.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { MissingFile as MissingFileWarning } from "./MissingFile"
 import { NegativeAmount as NegativeAmountWarning } from "./NegativeAmount"
 import { UnknownEntry as UnknownEntryWarning } from "./UnknownEntry"
@@ -14,4 +15,9 @@ export namespace Settlement {
 		MissingFile.type,
 		UnknownEntry.type
 	)
+	export const typeZod: zod.ZodType<Settlement> = zod.union([
+		NegativeAmount.typeZod,
+		MissingFile.typeZod,
+		UnknownEntry.typeZod,
+	])
 }

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

@@ -24,8 +24,8 @@ export declare namespace Fx {
         "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<{
+    }> & import("zod/v4/core").$partial, import("zod").ZodNumber>, import("zod").ZodObject<{
         default: import("zod").ZodNumber;
-    }, import("zod/v4/core/schemas.cjs").$strip>>;
+    }, import("zod/v4/core").$strip>>;
     function evaluate(charge: Fx, currency: isoly.Currency, amount: number, preset?: Card.Preset, exchange?: Exchange): Amount.Charge.Fx | undefined;
 }