@pax2pay/model-banking 0.1.660 → 0.1.663

package/Rail/Address/Bic.ts

@@ -0,0 +1,27 @@
+import { isly } from "isly"
+import { zod } from "../../zod"
+
+export interface Bic {
+	type: "bic"
+	account: string
+	institution: string // BIC, validated against the SWIFT directory by the supplier
+	holder: string
+	transactor?: string
+}
+export namespace Bic {
+	export const currencies = ["USD"] as const
+	export const type = isly.object<Bic>({
+		type: isly.string("bic"),
+		account: isly.string(),
+		institution: isly.string(),
+		holder: isly.string(),
+		transactor: isly.string().optional(),
+	})
+	export const typeZod = zod.object({
+		type: zod.literal("bic"),
+		account: zod.string(),
+		institution: zod.string(),
+		holder: zod.string(),
+		transactor: zod.string().optional(),
+	})
+}

package/Rail/Address/index.ts

@@ -1,6 +1,7 @@
 import { isly } from "isly"
 import { Realm } from "../../Realm"
 import { zod } from "../../zod"
+import { Bic as AddressBic } from "./Bic"
 import { Card as AddressCard } from "./Card"
 import { Iban as AddressIban } from "./Iban"
 import { Internal as AddressInternal } from "./internal"
@@ -15,13 +16,14 @@ export type Address =
 	| AddressInternal
 	| AddressPaxGiro
 	| AddressScan
+	| AddressBic
 export namespace Address {
 	export const realm: Record<Realm, string[]> = {
-		test: ["paxgiro", "internal", "iban", "scan", "card", "paxgiro-credit"],
+		test: ["paxgiro", "internal", "iban", "bic", "scan", "card", "paxgiro-credit"],
 		uk: ["internal", "iban", "scan", "card"],
 		eea: ["internal", "iban", "scan", "card"],
 	}
-	export const values = ["paxgiro", "internal", "iban", "scan", "card", "paxgiro-credit"] as const
+	export const values = ["paxgiro", "internal", "iban", "bic", "scan", "card", "paxgiro-credit"] as const
 	export type Type = (typeof values)[number]
 	export function compare(addresses: [Address, Address]): boolean {
 		return Object.entries(addresses[0]).every(([key, value]) => value == (addresses[1] as any)[key])
@@ -36,44 +38,50 @@ export namespace Address {
 		}
 		return result
 	}
-	export function stringify(Address: Address): string {
+	export function stringify(address: Address): string {
 		let result: string
-		switch (Address.type) {
+		switch (address.type) {
 			case "iban":
-				result = `iban-${Address.iban}`
+				result = `iban-${address.iban}`
 				break
 			case "paxgiro":
-				result = `pxg-${Address.identifier}`
+				result = `pxg-${address.identifier}`
 				break
 			case "internal":
-				result = `internal-${Address.identifier}`
+				result = `internal-${address.identifier}`
 				break
 			case "scan":
-				result = `scan-${Address.sort}-${Address.account}`
+				result = `scan-${address.sort}-${address.account}`
 				break
 			case "card":
-				result = "id" in Address ? `${Address.type}-${Address.id}` : `${Address.type}-merchant-${Address.merchant.id}`
+				result = "id" in address ? `${address.type}-${address.id}` : `${address.type}-merchant-${address.merchant.id}`
+				break
+			case "bic":
+				result = `bic-${address.institution}-${address.account}`
 				break
 		}
 		return result
 	}
-	export function beautify(Address: Address): string {
+	export function beautify(address: Address): string {
 		let result: string
-		switch (Address.type) {
+		switch (address.type) {
 			case "iban":
-				result = `${Address.iban}`
+				result = `${address.iban}`
 				break
 			case "paxgiro":
-				result = `${Address.identifier}`
+				result = `${address.identifier}`
 				break
 			case "internal":
-				result = `${Address.identifier}`
+				result = `${address.identifier}`
 				break
 			case "scan":
-				result = `${Address.sort} ${Address.account}`
+				result = `${address.sort} ${address.account}`
 				break
 			case "card":
-				result = "id" in Address ? `${Address.type}-${Address.id}` : `${Address.type}-merchant-${Address.merchant.id}`
+				result = "id" in address ? `${address.type}-${address.id}` : `${address.type}-merchant-${address.merchant.id}`
+				break
+			case "bic":
+				result = `${address.institution} ${address.account}`
 				break
 		}
 		return result
@@ -84,7 +92,8 @@ export namespace Address {
 		AddressIban.type,
 		AddressInternal.type,
 		AddressPaxGiro.type,
-		AddressScan.type
+		AddressScan.type,
+		AddressBic.type
 	)
 	export const typeZod = zod.union([
 		AddressCard.typeZod,
@@ -93,6 +102,7 @@ export namespace Address {
 		AddressInternal.typeZod,
 		AddressPaxGiro.typeZod,
 		AddressScan.typeZod,
+		AddressBic.typeZod,
 	])
 
 	export import PaxGiro = AddressPaxGiro
@@ -101,4 +111,5 @@ export namespace Address {
 	export import Internal = AddressInternal
 	export import Card = AddressCard
 	export import Route = AddressRoute
+	export import Bic = AddressBic
 }

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/Account/Details.d.ts

@@ -251,6 +251,12 @@ export declare namespace Details {
             account: zod.ZodString;
             holder: zod.ZodString;
             institution: zod.ZodOptional<zod.ZodString>;
+        }, zod.z.core.$strip>, zod.ZodObject<{
+            type: zod.ZodLiteral<"bic">;
+            account: zod.ZodString;
+            institution: zod.ZodString;
+            holder: zod.ZodString;
+            transactor: zod.ZodOptional<zod.ZodString>;
         }, zod.z.core.$strip>]>>;
     }, zod.z.core.$strip>;
     interface Creatable {

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

@@ -284,6 +284,12 @@ export declare namespace Account {
             account: zod.ZodString;
             holder: zod.ZodString;
             institution: zod.ZodOptional<zod.ZodString>;
+        }, zod.z.core.$strip>, zod.ZodObject<{
+            type: zod.ZodLiteral<"bic">;
+            account: zod.ZodString;
+            institution: zod.ZodString;
+            holder: zod.ZodString;
+            transactor: zod.ZodOptional<zod.ZodString>;
         }, zod.z.core.$strip>]>>;
         details: zod.ZodOptional<zod.ZodObject<{
             supplier: zod.ZodEnum<{
@@ -526,6 +532,12 @@ export declare namespace Account {
                 account: zod.ZodString;
                 holder: zod.ZodString;
                 institution: zod.ZodOptional<zod.ZodString>;
+            }, zod.z.core.$strip>, zod.ZodObject<{
+                type: zod.ZodLiteral<"bic">;
+                account: zod.ZodString;
+                institution: zod.ZodString;
+                holder: zod.ZodString;
+                transactor: zod.ZodOptional<zod.ZodString>;
             }, zod.z.core.$strip>]>>;
         }, zod.z.core.$strip>>;
         charges: zod.ZodOptional<zod.ZodObject<{

package/dist/cjs/Rail/Address/Bic.d.ts

@@ -0,0 +1,19 @@
+import { zod } from "../../zod";
+export interface Bic {
+    type: "bic";
+    account: string;
+    institution: string;
+    holder: string;
+    transactor?: string;
+}
+export declare namespace Bic {
+    const currencies: readonly ["USD"];
+    const type: import("isly/dist/cjs/object").IslyObject<Bic, object>;
+    const typeZod: zod.ZodObject<{
+        type: zod.ZodLiteral<"bic">;
+        account: zod.ZodString;
+        institution: zod.ZodString;
+        holder: zod.ZodString;
+        transactor: zod.ZodOptional<zod.ZodString>;
+    }, zod.z.core.$strip>;
+}

package/dist/cjs/Rail/Address/Bic.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bic = void 0;
+const isly_1 = require("isly");
+const zod_1 = require("../../zod");
+var Bic;
+(function (Bic) {
+    Bic.currencies = ["USD"];
+    Bic.type = isly_1.isly.object({
+        type: isly_1.isly.string("bic"),
+        account: isly_1.isly.string(),
+        institution: isly_1.isly.string(),
+        holder: isly_1.isly.string(),
+        transactor: isly_1.isly.string().optional(),
+    });
+    Bic.typeZod = zod_1.zod.object({
+        type: zod_1.zod.literal("bic"),
+        account: zod_1.zod.string(),
+        institution: zod_1.zod.string(),
+        holder: zod_1.zod.string(),
+        transactor: zod_1.zod.string().optional(),
+    });
+})(Bic || (exports.Bic = Bic = {}));
+//# sourceMappingURL=Bic.js.map

package/dist/cjs/Rail/Address/Bic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bic.js","sourceRoot":"","sources":["../../../../Rail/Address/Bic.ts"],"names":[],"mappings":";;;AAAA,+BAA2B;AAC3B,mCAA+B;AAS/B,IAAiB,GAAG,CAgBnB;AAhBD,WAAiB,GAAG;IACN,cAAU,GAAG,CAAC,KAAK,CAAU,CAAA;IAC7B,QAAI,GAAG,WAAI,CAAC,MAAM,CAAM;QACpC,IAAI,EAAE,WAAI,CAAC,MAAM,CAAC,KAAK,CAAC;QACxB,OAAO,EAAE,WAAI,CAAC,MAAM,EAAE;QACtB,WAAW,EAAE,WAAI,CAAC,MAAM,EAAE;QAC1B,MAAM,EAAE,WAAI,CAAC,MAAM,EAAE;QACrB,UAAU,EAAE,WAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACpC,CAAC,CAAA;IACW,WAAO,GAAG,SAAG,CAAC,MAAM,CAAC;QACjC,IAAI,EAAE,SAAG,CAAC,OAAO,CAAC,KAAK,CAAC;QACxB,OAAO,EAAE,SAAG,CAAC,MAAM,EAAE;QACrB,WAAW,EAAE,SAAG,CAAC,MAAM,EAAE;QACzB,MAAM,EAAE,SAAG,CAAC,MAAM,EAAE;QACpB,UAAU,EAAE,SAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACnC,CAAC,CAAA;AACH,CAAC,EAhBgB,GAAG,mBAAH,GAAG,QAgBnB"}

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

@@ -1,21 +1,22 @@
 import { isly } from "isly";
 import { Realm } from "../../Realm";
 import { zod } from "../../zod";
+import { Bic as AddressBic } from "./Bic";
 import { Card as AddressCard } from "./Card";
 import { Iban as AddressIban } from "./Iban";
 import { Internal as AddressInternal } from "./internal";
 import { PaxGiro as AddressPaxGiro } from "./PaxGiro";
 import { Route as AddressRoute } from "./Route";
 import { Scan as AddressScan } from "./Scan";
-export type Address = AddressCard | AddressCard.Counterpart | AddressIban | AddressInternal | AddressPaxGiro | AddressScan;
+export type Address = AddressCard | AddressCard.Counterpart | AddressIban | AddressInternal | AddressPaxGiro | AddressScan | AddressBic;
 export declare namespace Address {
     const realm: Record<Realm, string[]>;
-    const values: readonly ["paxgiro", "internal", "iban", "scan", "card", "paxgiro-credit"];
+    const values: readonly ["paxgiro", "internal", "iban", "bic", "scan", "card", "paxgiro-credit"];
     type Type = (typeof values)[number];
     function compare(addresses: [Address, Address]): boolean;
     function parse(value: string): Address | undefined;
-    function stringify(Address: Address): string;
-    function beautify(Address: Address): string;
+    function stringify(address: Address): string;
+    function beautify(address: Address): string;
     const type: isly.Type<Address>;
     const typeZod: zod.ZodUnion<readonly [zod.ZodObject<{
         type: zod.ZodLiteral<"card">;
@@ -70,6 +71,12 @@ export declare namespace Address {
         account: zod.ZodString;
         holder: zod.ZodString;
         institution: zod.ZodOptional<zod.ZodString>;
+    }, zod.z.core.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"bic">;
+        account: zod.ZodString;
+        institution: zod.ZodString;
+        holder: zod.ZodString;
+        transactor: zod.ZodOptional<zod.ZodString>;
     }, zod.z.core.$strip>]>;
     export import PaxGiro = AddressPaxGiro;
     export import Iban = AddressIban;
@@ -77,4 +84,5 @@ export declare namespace Address {
     export import Internal = AddressInternal;
     export import Card = AddressCard;
     export import Route = AddressRoute;
+    export import Bic = AddressBic;
 }