@pax2pay/model-banking 0.1.660 → 0.1.661

package/Rail/index.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 import { Address as RailAddress } from "./Address"
 
 export type Rail = (typeof Rail.rails)[number]
@@ -21,5 +22,6 @@ export namespace Rail {
 		"rix-inst",
 	] as const
 	export const type = isly.string<Rail>(rails)
+	export const typeZod = zod.enum(rails)
 	export import Address = RailAddress
 }

package/Transaction/Amount/Charge/index.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Card } from "../../../Card"
+import { zod } from "../../../zod"
 
 export interface Charge {
 	merchant?: Charge.Merchant
@@ -18,6 +19,11 @@ export namespace Charge {
 			rate: isly.number(),
 			preset: isly.union(Card.Preset.type, isly.string("default")),
 		})
+		export const typeZod = zod.object({
+			amount: zod.number(),
+			rate: zod.number(),
+			preset: zod.union([Card.Preset.typeZod, zod.literal("default")]),
+		})
 	}
 	export interface Merchant {
 		amount: number
@@ -36,6 +42,13 @@ export namespace Charge {
 				account: isly.string(),
 			}),
 		})
+		export const typeZod = zod.object({
+			amount: zod.number(),
+			rate: zod.number(),
+			merchant: Card.Restriction.Merchant.typeZod,
+			preset: zod.union([Card.Preset.typeZod, zod.literal("default")]),
+			destination: zod.object({ account: zod.string() }),
+		})
 	}
 	export function total(currency: isoly.Currency, charges: Charge): number {
 		return isoly.Currency.add(currency, charges.fx?.amount ?? 0, charges.merchant?.amount ?? 0)
@@ -44,4 +57,8 @@ export namespace Charge {
 		merchant: Charge.Merchant.type.optional(),
 		fx: Charge.Fx.type.optional(),
 	})
+	export const typeZod = zod.object({
+		merchant: Charge.Merchant.typeZod.optional(),
+		fx: Charge.Fx.typeZod.optional(),
+	})
 }

package/Transaction/Amount/index.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { Exchange } from "../Exchange"
 import { Charge as AmountCharge } from "./Charge"
 
@@ -19,6 +20,13 @@ export namespace Amount {
 		total: isly.number(),
 		exchange: Exchange.type.optional(),
 	})
+	export const typeZod = zod.object({
+		original: zod.number(),
+		charge: zod.number(),
+		charges: Amount.Charge.typeZod.optional(),
+		total: zod.number(),
+		exchange: Exchange.typeZod.optional(),
+	})
 	export function change(
 		currency: isoly.Currency,
 		amount: Amount,

package/Transaction/Creatable.ts

@@ -3,6 +3,7 @@ import { isly } from "isly"
 import { Account } from "../Account"
 import { Preset } from "../Card/Preset"
 import { Rail } from "../Rail"
+import { zod } from "../zod"
 import { Amount } from "./Amount"
 import { Exchange } from "./Exchange"
 
@@ -24,6 +25,14 @@ export namespace Creatable {
 		exchange: Exchange.type.optional(),
 		reference: isly.object<{ reference?: string }>({ reference: isly.string().optional() }).optional(),
 	})
+	export const typeZod = zod.object({
+		counterpart: Rail.Address.typeZod,
+		currency: zod.enum(isoly.Currency.values),
+		amount: zod.number(),
+		description: zod.string(),
+		exchange: Exchange.typeZod.optional(),
+		reference: zod.object({ reference: zod.string().optional() }).optional(),
+	})
 	export interface CardTransaction extends Creatable {
 		account: Pick<Rail.Address.Card, "id" | "type">
 		accountId: string
@@ -39,6 +48,13 @@ export namespace Creatable {
 			reference: isly.object<{ reference: string }>({ reference: isly.string() }),
 			approvalCode: isly.string().optional(),
 		})
+		export const typeZod = Creatable.typeZod.extend({
+			account: Rail.Address.Card.typeZod.pick({ id: true, type: true }),
+			accountId: zod.string(),
+			counterpart: Rail.Address.Card.Counterpart.typeZod,
+			reference: zod.object({ reference: zod.string() }),
+			approvalCode: zod.string().optional(),
+		})
 		export function charge(creatable: CardTransaction, preset: Preset, charges?: Account.Charge): Amount.Charge {
 			return Account.Charge.evaluate(
 				creatable.counterpart,

package/Transaction/Exchange.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Amount } from "../Amount"
+import { zod } from "../zod"
 
 export interface Exchange {
 	rate: number
@@ -14,4 +15,10 @@ export namespace Exchange {
 		from: Amount.type.optional(),
 		quote: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		rate: zod.number(),
+		to: Amount.typeZod.optional(),
+		from: Amount.typeZod.optional(),
+		quote: zod.string().optional(),
+	})
 }

package/Transaction/Identifier.ts

@@ -4,6 +4,7 @@ import { Identifier as Pax2PayIdentifier } from "../Identifier"
 export type Identifier = Pax2PayIdentifier
 export namespace Identifier {
 	export const type = Pax2PayIdentifier.type
+	export const typeZod = Pax2PayIdentifier.typeZod
 	export function generate(): string {
 		//This function will stop working 4199-11-24T01:22:57.664Z
 		//Then we need to replace "zzy" instead

package/Transaction/Incoming.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../Rail"
+import { zod } from "../zod"
 import { Reference as TransactionReference } from "./Reference"
 
 export interface Incoming {
@@ -24,4 +25,14 @@ export namespace Incoming {
 		rail: Rail.type.optional(),
 		reference: TransactionReference.type.optional(),
 	})
+	export const typeZod = zod.object({
+		account: Rail.Address.typeZod,
+		counterpart: Rail.Address.typeZod,
+		currency: zod.enum(isoly.Currency.values),
+		amount: zod.number(),
+		description: zod.string(),
+		posted: zod.string(),
+		rail: Rail.typeZod.optional(),
+		reference: TransactionReference.typeZod.optional(),
+	})
 }

package/Transaction/Note.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export interface Note extends Note.Creatable {
 	author: string
@@ -32,9 +33,19 @@ export namespace Note {
 			flags: isly.string().array().optional(),
 			rule: isly.any().optional(),
 		})
+		export const typeZod = zod.object({
+			text: zod.string().optional(),
+			action: zod.enum(["approve", "reject"]).optional(),
+			flags: zod.array(zod.string()).optional(),
+			rule: zod.any().optional(),
+		})
 	}
 	export const type = Creatable.type.extend<Note>({
 		author: isly.string(),
 		created: isly.string(),
 	})
+	export const typeZod = Creatable.typeZod.extend({
+		author: zod.string(),
+		created: zod.string().refine(isoly.DateTime.is),
+	})
 }

package/Transaction/PreTransaction/Authorization.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Rail } from "../../Rail"
+import { zod } from "../../zod"
 import { Base } from "./Base"
 
 export interface Authorization extends Base {
@@ -17,4 +18,11 @@ export namespace Authorization {
 		reference: isly.object<{ reference: string }>({ reference: isly.string() }),
 		approvalCode: isly.string().optional(),
 	})
+	export const typeZod = Base.typeZod.extend({
+		type: zod.literal("authorization"),
+		account: Rail.Address.Card.typeZod.pick({ id: true, type: true }),
+		counterpart: Rail.Address.Card.Counterpart.typeZod,
+		reference: zod.object({ reference: zod.string() }),
+		approvalCode: zod.string().optional(),
+	})
 }

package/Transaction/PreTransaction/Base.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../../Rail"
+import { zod } from "../../zod"
 import { Exchange } from "../Exchange"
 
 export interface Base {
@@ -20,4 +21,12 @@ export namespace Base {
 		description: isly.string(),
 		exchange: Exchange.type.optional(),
 	})
+	export const typeZod = zod.object({
+		type: zod.enum(["outgoing", "incoming", "authorization"]),
+		counterpart: Rail.Address.typeZod,
+		currency: zod.enum(isoly.Currency.values),
+		amount: zod.number(),
+		description: zod.string(),
+		exchange: Exchange.typeZod.optional(),
+	})
 }

package/Transaction/PreTransaction/Incoming.ts

@@ -2,6 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Rail } from "../../Rail"
 import { Settlement } from "../../Settlement"
+import { zod } from "../../zod"
 import { Reference as TransactionReference } from "../Reference"
 import { Base } from "./Base"
 
@@ -26,6 +27,16 @@ export namespace Incoming {
 		rail: Rail.type.optional(),
 		reference: TransactionReference.type.optional(),
 	})
+	export const typeZod = Base.typeZod.extend({
+		type: zod.literal("incoming"),
+		account: Rail.Address.typeZod,
+		currency: zod.enum(isoly.Currency.values),
+		amount: zod.number(),
+		description: zod.string(),
+		posted: zod.string(),
+		rail: Rail.typeZod.optional(),
+		reference: TransactionReference.typeZod.optional(),
+	})
 	export function fromRefund(entry: Settlement.Entry.Creatable.Refund, card: Rail.Address.Card): Incoming {
 		const [currency, amount] = entry.amount
 		return {

package/Transaction/PreTransaction/Outgoing.ts

@@ -1,8 +1,9 @@
-import type { Base } from "./Base"
+import { zod } from "../../zod"
+import { Base } from "./Base"
 
 export interface Outgoing extends Base {
 	type: "outgoing"
 }
 export namespace Outgoing {
-	export const dummy = true
+	export const typeZod = Base.typeZod.extend({ type: zod.literal("outgoing") })
 }

package/Transaction/PreTransaction/index.ts

@@ -1,4 +1,5 @@
 import { Rail } from "../../Rail"
+import { zod } from "../../zod"
 import { Authorization as PreTransactionAuthorization } from "./Authorization"
 import { Incoming as PreTransactionIncoming } from "./Incoming"
 import { Outgoing as PreTransactionOutgoing } from "./Outgoing"
@@ -13,4 +14,5 @@ export namespace PreTransaction {
 	export import Authorization = PreTransactionAuthorization
 	export import Incoming = PreTransactionIncoming
 	export import Outgoing = PreTransactionOutgoing
+	export const typeZod = zod.union([Outgoing.typeZod, Authorization.typeZod, Incoming.typeZod])
 }

package/Transaction/Reference.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Supplier } from "../Supplier"
+import { zod } from "../zod"
 
 export interface Reference {
 	supplier?: Supplier
@@ -19,4 +20,12 @@ export namespace Reference {
 		instruction: isly.string().optional(),
 		network: isly.string().optional(),
 	})
+	export const typeZod = zod.object({
+		supplier: Supplier.typeZod.optional(),
+		reference: zod.string().optional(),
+		returnId: zod.string().optional(),
+		endToEndId: zod.string().optional(),
+		instruction: zod.string().optional(),
+		network: zod.string().optional(),
+	})
 }

package/Transaction/Status.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export type Status = Status.Success | [Status.Fail, Status.Reason]
 export namespace Status {
@@ -27,4 +28,5 @@ export namespace Status {
 		Success,
 		isly.tuple<[Fail, Status.Reason]>(Fail, Reason)
 	)
+	export const typeZod = zod.union([zod.enum(successes), zod.tuple([zod.enum(failures), zod.enum(reasons)])])
 }

package/Transaction/index.ts

@@ -7,6 +7,7 @@ import { Rail } from "../Rail"
 import { Report } from "../Report"
 import type { Rule } from "../Rule"
 import { Settlement } from "../Settlement"
+import { zod } from "../zod"
 import { Amount as TransactionAmount } from "./Amount"
 import { Creatable as TransactionCreatable } from "./Creatable"
 import { Exchange as TransactionExchange } from "./Exchange"
@@ -85,6 +86,32 @@ export namespace Transaction {
 		risk: isly.number().optional(),
 		state: isly.any().optional(),
 	})
+	export const typeZod = zod.object({
+		counterpart: Rail.Address.typeZod,
+		currency: zod.enum(isoly.Currency.values),
+		amount: Amount.typeZod,
+		description: zod.string(),
+		organization: zod.string(),
+		accountId: zod.string(),
+		accountName: zod.string().optional(),
+		account: Rail.Address.typeZod,
+		type: zod.enum(types).optional(),
+		direction: zod.enum(directions).optional(),
+		id: Identifier.typeZod,
+		reference: Reference.typeZod.optional(),
+		posted: zod.string().refine(isoly.DateTime.is),
+		transacted: zod.string().refine(isoly.DateTime.is).optional(),
+		by: zod.string().optional(),
+		balance: zod.object({ actual: zod.number(), available: zod.number(), reserved: zod.number() }),
+		operations: zod.array(Operation.typeZod).optional(),
+		status: Status.typeZod,
+		rail: Rail.typeZod.optional(),
+		flags: zod.array(zod.string()),
+		oldFlags: zod.array(zod.string()),
+		notes: zod.array(Note.typeZod),
+		risk: zod.number().optional(),
+		state: zod.any().optional(),
+	})
 	export function amountFromOperations(transaction: Transaction, operations: Operation[]): Amount {
 		const changes = Operation.sum(operations)
 		const reserved = isoly.Currency.add(
@@ -105,6 +132,7 @@ export namespace Transaction {
 	}
 	export namespace Legacy {
 		export const type = Transaction.type.omit<"amount">(["amount"]).extend<Legacy>({ amount: isly.number() })
+		export const typeZod = Transaction.typeZod.omit({ amount: true }).extend({ amount: zod.number() })
 	}
 	export function fromLegacy(transaction: Transaction | Legacy): Transaction {
 		return {
@@ -131,6 +159,7 @@ export namespace Transaction {
 	export type Event = Omit<Transaction, "state">
 	export namespace Event {
 		export const type = Transaction.type.omit(["state"])
+		export const typeZod = Transaction.typeZod.omit({ state: true })
 
 		export function from(transaction: Transaction): Event {
 			return (({ state, ...event }) => event)(transaction)
@@ -384,5 +413,9 @@ export namespace Transaction {
 			account: Rail.Address.Card.type,
 			counterpart: Rail.Address.Card.Counterpart.type,
 		})
+		export const typeZod = Transaction.typeZod.omit({ account: true, counterpart: true }).extend({
+			account: Rail.Address.Card.typeZod,
+			counterpart: Rail.Address.Card.Counterpart.typeZod,
+		})
 	}
 }

package/dist/cjs/Rail/index.d.ts

@@ -1,8 +1,26 @@
 import { isly } from "isly";
+import { zod } from "../zod";
 import { Address as RailAddress } from "./Address";
 export type Rail = (typeof Rail.rails)[number];
 export declare namespace Rail {
     const rails: readonly ["internal", "paxgiro", "paxgiro-credit", "mastercard", "diners", "visa", "fasterpayments", "chaps", "bacs", "transfer", "credit", "sepa", "sepa-instant", "rix-rtgs", "rix-inst"];
     const type: isly.Type<"paxgiro" | "mastercard" | "diners" | "visa" | "internal" | "transfer" | "paxgiro-credit" | "fasterpayments" | "chaps" | "bacs" | "credit" | "sepa" | "sepa-instant" | "rix-rtgs" | "rix-inst">;
+    const typeZod: zod.ZodEnum<{
+        paxgiro: "paxgiro";
+        mastercard: "mastercard";
+        diners: "diners";
+        visa: "visa";
+        internal: "internal";
+        transfer: "transfer";
+        "paxgiro-credit": "paxgiro-credit";
+        fasterpayments: "fasterpayments";
+        chaps: "chaps";
+        bacs: "bacs";
+        credit: "credit";
+        sepa: "sepa";
+        "sepa-instant": "sepa-instant";
+        "rix-rtgs": "rix-rtgs";
+        "rix-inst": "rix-inst";
+    }>;
     export import Address = RailAddress;
 }

package/dist/cjs/Rail/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rail = void 0;
 const isly_1 = require("isly");
+const zod_1 = require("../zod");
 const Address_1 = require("./Address");
 var Rail;
 (function (Rail) {
@@ -23,6 +24,7 @@ var Rail;
         "rix-inst",
     ];
     Rail.type = isly_1.isly.string(Rail.rails);
+    Rail.typeZod = zod_1.zod.enum(Rail.rails);
     Rail.Address = Address_1.Address;
 })(Rail || (exports.Rail = Rail = {}));
 //# sourceMappingURL=index.js.map

package/dist/cjs/Rail/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../Rail/index.ts"],"names":[],"mappings":";;;AAAA,+BAA2B;AAC3B,uCAAkD;AAGlD,IAAiB,IAAI,CAoBpB;AApBD,WAAiB,IAAI;IACP,UAAK,GAAG;QACpB,UAAU;QACV,SAAS;QACT,gBAAgB;QAChB,YAAY;QACZ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,OAAO;QACP,MAAM;QACN,UAAU;QACV,QAAQ;QACR,MAAM;QACN,cAAc;QACd,UAAU;QACV,UAAU;KACD,CAAA;IACG,SAAI,GAAG,WAAI,CAAC,MAAM,CAAO,KAAA,KAAK,CAAC,CAAA;IAC9B,YAAO,GAAG,iBAAW,CAAA;AACpC,CAAC,EApBgB,IAAI,oBAAJ,IAAI,QAoBpB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../Rail/index.ts"],"names":[],"mappings":";;;AAAA,+BAA2B;AAC3B,gCAA4B;AAC5B,uCAAkD;AAGlD,IAAiB,IAAI,CAqBpB;AArBD,WAAiB,IAAI;IACP,UAAK,GAAG;QACpB,UAAU;QACV,SAAS;QACT,gBAAgB;QAChB,YAAY;QACZ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,OAAO;QACP,MAAM;QACN,UAAU;QACV,QAAQ;QACR,MAAM;QACN,cAAc;QACd,UAAU;QACV,UAAU;KACD,CAAA;IACG,SAAI,GAAG,WAAI,CAAC,MAAM,CAAO,KAAA,KAAK,CAAC,CAAA;IAC/B,YAAO,GAAG,SAAG,CAAC,IAAI,CAAC,KAAA,KAAK,CAAC,CAAA;IACxB,YAAO,GAAG,iBAAW,CAAA;AACpC,CAAC,EArBgB,IAAI,oBAAJ,IAAI,QAqBpB"}