@pax2pay/model-banking 0.1.658 → 0.1.660

package/Amount.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amounts } from "./Amounts"
+import { zod } from "./zod"
 
 export type Amount = [isoly.Currency, number]
 
@@ -9,4 +10,5 @@ export namespace Amount {
 		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()])
 }

package/Balance.ts

@@ -26,15 +26,25 @@ export namespace Balance {
 		export namespace Entry {
 			export const values = ["actual", "incomingReserved", "outgoingReserved", "bufferReserved"] as const
 			export const type = isly.string<Entry>(values)
+			export const typeZod = zod.enum(values)
 		}
 		export const type = isly.record<Legacy>(Entry.type, isly.number())
+		export const typeZod = zod.partialRecord(Entry.typeZod, zod.number())
 	}
 	export type MaybeLegacy = Balance | Legacy
 	export namespace MaybeLegacy {
 		export const legacyType = isly.union<MaybeLegacy>(type, Legacy.type)
 	}
 	export type Extended = Balance & Legacy
-	export const Extended = isly.intersection<Extended, Balance, Legacy>(type, Legacy.type)
+	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 function update(currency: isoly.Currency, balance: MaybeLegacy): Extended {
 		const result: Extended = { ...balance }
 		if (Legacy.type.is(balance)) {

package/Balances.ts

@@ -9,7 +9,7 @@ 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 const typeZod = zod.partialRecord(zod.enum(isoly.Currency.values), Balances.Balance.Extended.typeZod)
 	export function update(balances: Balances): Balances {
 		const result: Balances = {}
 		for (const [currency, balance] of Object.entries(balances)) {

package/Card/Changeable.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amount } from "../Amount"
+import { zod } from "../zod"
 import { Meta } from "./Meta"
 
 export type Changeable = {
@@ -13,4 +14,8 @@ export namespace Changeable {
 		limit: isly.tuple(isly.fromIs("isoly.Currency", isoly.Currency.is), isly.number()).optional(),
 		meta: isly.fromIs("Card.Meta", Meta.is).optional(),
 	})
+	export const typeZod = zod.object({
+		limit: Amount.typeZod.optional(),
+		meta: Meta.typeZod.optional(),
+	})
 }

package/Card/Creatable.ts

@@ -3,6 +3,7 @@ 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"
 import { Preset } from "./Preset"
@@ -35,4 +36,15 @@ export namespace Creatable {
 		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(),
+	})
 }

package/Card/Meta.ts

@@ -1,3 +1,5 @@
+import { zod } from "../zod"
+
 export interface Meta {
 	[key: string]: any
 }
@@ -14,4 +16,5 @@ export namespace Meta {
 			typeof value == "boolean"
 		)
 	}
+	export const typeZod = zod.any().refine(Meta.is)
 }

package/Card/Operation/Authorization.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 
 export interface Authorization {
 	type: "authorization"
@@ -18,4 +19,11 @@ export namespace Authorization {
 		reason: isly.string().optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("authorization"),
+		id: zod.string(),
+		status: zod.enum(statuses),
+		reason: zod.string().optional(),
+		created: zod.string().refine(isoly.DateTime.is),
+	})
 }

package/Card/Operation/Card.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { Changeable } from "../Changeable"
 
 export interface Card {
@@ -18,4 +19,10 @@ export namespace Card {
 		from: Changeable.type.optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})
+	export const typeZod = zod.object({
+		type: zod.literal("card"),
+		status: zod.enum(statuses),
+		from: Changeable.typeZod.optional(),
+		created: zod.string().refine(isoly.DateTime.is),
+	})
 }

package/Card/Operation/index.ts

@@ -2,6 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Authorization } from "../../Authorization"
 import { Entry } from "../../Settlement/Entry"
+import { zod } from "../../zod"
 import { Authorization as OperationAuthorization } from "./Authorization"
 import { Card } from "./Card"
 
@@ -27,4 +28,5 @@ export namespace Operation {
 				}
 	}
 	export const type = isly.union(Card.type, OperationAuthorization.type)
+	export const typeZod = zod.union([Card.typeZod, OperationAuthorization.typeZod])
 }

package/Card/Restriction/index.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import type { Transaction } from "../../Transaction"
+import { zod } from "../../zod"
 import { Merchant as RestrictionsMerchant } from "./Merchant"
 
 export interface Restriction {
@@ -8,6 +9,7 @@ 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 function check(
 		restrictions: Restriction,
 		transaction: Transaction.Creatable.CardTransaction | Transaction.PreTransaction.Authorization

package/Card/Stack.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Realm } from "../Realm"
+import { zod } from "../zod"
 
 export type Stack = (typeof Stack.stacks)[number]
 
@@ -11,15 +12,18 @@ export namespace Stack {
 		export const uk = ["uk-visa-tpl-marqeta", "uk-diners-clowd9"] as const
 		export const values = [...test, ...uk] as const
 		export const type = isly.string([...test, ...uk])
+		export const typeZod = zod.enum([...test, ...uk])
 	}
 	export type Decommissioned = (typeof Decommissioned.values)[number]
 	export namespace Decommissioned {
 		export const uk = ["uk-diners-dpg", "uk-mc-tpl-marqeta"] as const
 		export const values = [...uk] as const
 		export const type = isly.string(values)
+		export const typeZod = zod.enum(values)
 	}
 	export const stacks = [...Active.values, ...Decommissioned.values] as const
 	export const type = isly.string(stacks)
+	export const typeZod = zod.enum(stacks)
 	export function toRealm(stack: Stack): Realm {
 		return stack.split("-")[0] as Realm
 	}

package/Card/index.ts

@@ -5,6 +5,7 @@ import { Realm } from "../Realm"
 import { Report } from "../Report"
 import type { Rule } from "../Rule"
 import { type as ruleType } from "../Rule/type"
+import { zod } from "../zod"
 import { Changeable as CardChangeable } from "./Changeable"
 import { Creatable as CardCreatable } from "./Creatable"
 import { Expiry as CardExpiry } from "./Expiry"
@@ -75,6 +76,31 @@ export namespace Card {
 		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(),
+	})
 	const csvMap: Record<string, (card: Card) => string | number | undefined> = {
 		id: card => card.id,
 		created: card => readableDate(card.created),

package/Operation/Change.ts

@@ -1,4 +1,5 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 import { Status } from "./Status"
 
 export interface Change<T extends Change.Operand = Change.Operand> {
@@ -17,6 +18,12 @@ 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 namespace Add {
 		export const type = Change.type.extend<Change<"add">>({
 			type: isly.string("add"),

package/Operation/Changes.ts

@@ -2,6 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Balance as AccountBalance } from "../Balance"
 import type { Settlement } from "../Settlement"
+import { zod } from "../zod"
 import { Change } from "./Change"
 
 export type Changes = Partial<Record<Changes.Entry.Balance, Change>>
@@ -47,6 +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 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,6 +2,7 @@ import { cryptly } from "cryptly"
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Settlement } from "../Settlement"
+import { zod } from "../zod"
 import { Changes } from "./Changes"
 
 export interface Creatable {
@@ -37,6 +38,13 @@ 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 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

@@ -1,8 +1,10 @@
 import { isly } from "isly"
+import { zod } from "../zod"
 
 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)
 }

package/Operation/index.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 import { Change as OperationChange } from "./Change"
 import { Changes as OperationChanges } from "./Changes"
 import { Creatable as OperationCreatable } from "./Creatable"
@@ -34,6 +35,13 @@ 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 type = OperationCreatable.type.extend<Operation>({
 		transaction: isly.string(),
 		counter: isly.number(),

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

@@ -208,7 +208,7 @@ export declare namespace Details {
             id: zod.ZodString;
             iin: zod.ZodString;
             last4: zod.ZodString;
-            expiry: zod.ZodTuple<[zod.ZodLiteral<26 | 23 | 24 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>, zod.ZodLiteral<2 | 1 | 3 | 4 | 5 | 6 | 11 | 8 | 9 | 7 | 10 | 12>], null>;
+            expiry: zod.ZodTuple<[zod.ZodLiteral<26 | 23 | 24 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>, zod.ZodLiteral<2 | 1 | 4 | 3 | 5 | 6 | 11 | 8 | 9 | 7 | 10 | 12>], null>;
             holder: zod.ZodString;
         }, zod.z.core.$strip>, zod.ZodObject<{
             type: zod.ZodLiteral<"card">;

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

@@ -226,6 +226,10 @@ export declare namespace Account {
                 outgoing: "outgoing";
                 buffer: "buffer";
             }> & zod.z.core.$partial, zod.ZodOptional<zod.ZodNumber>>>;
+            actual: zod.ZodOptional<zod.ZodNumber>;
+            incomingReserved: zod.ZodOptional<zod.ZodNumber>;
+            outgoingReserved: zod.ZodOptional<zod.ZodNumber>;
+            bufferReserved: zod.ZodOptional<zod.ZodNumber>;
         }, zod.z.core.$strip>>;
         rails: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
             type: zod.ZodLiteral<"card">;
@@ -237,7 +241,7 @@ export declare namespace Account {
             id: zod.ZodString;
             iin: zod.ZodString;
             last4: zod.ZodString;
-            expiry: zod.ZodTuple<[zod.ZodLiteral<26 | 23 | 24 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>, zod.ZodLiteral<2 | 1 | 3 | 4 | 5 | 6 | 11 | 8 | 9 | 7 | 10 | 12>], null>;
+            expiry: zod.ZodTuple<[zod.ZodLiteral<26 | 23 | 24 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>, zod.ZodLiteral<2 | 1 | 4 | 3 | 5 | 6 | 11 | 8 | 9 | 7 | 10 | 12>], null>;
             holder: zod.ZodString;
         }, zod.z.core.$strip>, zod.ZodObject<{
             type: zod.ZodLiteral<"card">;
@@ -479,7 +483,7 @@ export declare namespace Account {
                 id: zod.ZodString;
                 iin: zod.ZodString;
                 last4: zod.ZodString;
-                expiry: zod.ZodTuple<[zod.ZodLiteral<26 | 23 | 24 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>, zod.ZodLiteral<2 | 1 | 3 | 4 | 5 | 6 | 11 | 8 | 9 | 7 | 10 | 12>], null>;
+                expiry: zod.ZodTuple<[zod.ZodLiteral<26 | 23 | 24 | 25 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>, zod.ZodLiteral<2 | 1 | 4 | 3 | 5 | 6 | 11 | 8 | 9 | 7 | 10 | 12>], null>;
                 holder: zod.ZodString;
             }, zod.z.core.$strip>, zod.ZodObject<{
                 type: zod.ZodLiteral<"card">;

package/dist/cjs/Amount.d.ts

@@ -1,8 +1,190 @@
 import { isoly } from "isoly";
 import { isly } from "isly";
 import { Amounts } from "./Amounts";
+import { zod } from "./zod";
 export type Amount = [isoly.Currency, number];
 export declare namespace Amount {
     function toAmounts(amount?: Amount): Amounts;
     const type: isly.Type<Amount>;
+    const typeZod: zod.ZodTuple<[zod.ZodEnum<{
+        AED: "AED";
+        AFN: "AFN";
+        ALL: "ALL";
+        AMD: "AMD";
+        ANG: "ANG";
+        AOA: "AOA";
+        ARS: "ARS";
+        AUD: "AUD";
+        AWG: "AWG";
+        AZN: "AZN";
+        BAM: "BAM";
+        BBD: "BBD";
+        BDT: "BDT";
+        BGN: "BGN";
+        BHD: "BHD";
+        BIF: "BIF";
+        BMD: "BMD";
+        BND: "BND";
+        BOB: "BOB";
+        BOV: "BOV";
+        BRL: "BRL";
+        BSD: "BSD";
+        BTN: "BTN";
+        BWP: "BWP";
+        BYN: "BYN";
+        BZD: "BZD";
+        CAD: "CAD";
+        CDF: "CDF";
+        CHE: "CHE";
+        CHF: "CHF";
+        CHW: "CHW";
+        CLF: "CLF";
+        CLP: "CLP";
+        CNY: "CNY";
+        COP: "COP";
+        COU: "COU";
+        CRC: "CRC";
+        CUC: "CUC";
+        CUP: "CUP";
+        CVE: "CVE";
+        CZK: "CZK";
+        DJF: "DJF";
+        DKK: "DKK";
+        DOP: "DOP";
+        DZD: "DZD";
+        EGP: "EGP";
+        ERN: "ERN";
+        ETB: "ETB";
+        EUR: "EUR";
+        FJD: "FJD";
+        FKP: "FKP";
+        GBP: "GBP";
+        GEL: "GEL";
+        GHS: "GHS";
+        GIP: "GIP";
+        GMD: "GMD";
+        GNF: "GNF";
+        GTQ: "GTQ";
+        GYD: "GYD";
+        HKD: "HKD";
+        HNL: "HNL";
+        HRK: "HRK";
+        HTG: "HTG";
+        HUF: "HUF";
+        IDR: "IDR";
+        ILS: "ILS";
+        INR: "INR";
+        IQD: "IQD";
+        IRR: "IRR";
+        ISK: "ISK";
+        JMD: "JMD";
+        JOD: "JOD";
+        JPY: "JPY";
+        KES: "KES";
+        KGS: "KGS";
+        KHR: "KHR";
+        KMF: "KMF";
+        KPW: "KPW";
+        KRW: "KRW";
+        KWD: "KWD";
+        KYD: "KYD";
+        KZT: "KZT";
+        LAK: "LAK";
+        LBP: "LBP";
+        LKR: "LKR";
+        LRD: "LRD";
+        LSL: "LSL";
+        LYD: "LYD";
+        MAD: "MAD";
+        MDL: "MDL";
+        MGA: "MGA";
+        MKD: "MKD";
+        MMK: "MMK";
+        MNT: "MNT";
+        MOP: "MOP";
+        MRU: "MRU";
+        MUR: "MUR";
+        MVR: "MVR";
+        MWK: "MWK";
+        MXN: "MXN";
+        MXV: "MXV";
+        MYR: "MYR";
+        MZN: "MZN";
+        NAD: "NAD";
+        NGN: "NGN";
+        NIO: "NIO";
+        NOK: "NOK";
+        NPR: "NPR";
+        NZD: "NZD";
+        OMR: "OMR";
+        PAB: "PAB";
+        PEN: "PEN";
+        PGK: "PGK";
+        PHP: "PHP";
+        PKR: "PKR";
+        PLN: "PLN";
+        PYG: "PYG";
+        QAR: "QAR";
+        RON: "RON";
+        RSD: "RSD";
+        RUB: "RUB";
+        RWF: "RWF";
+        SAR: "SAR";
+        SBD: "SBD";
+        SCR: "SCR";
+        SDG: "SDG";
+        SEK: "SEK";
+        SGD: "SGD";
+        SHP: "SHP";
+        SLL: "SLL";
+        SOS: "SOS";
+        SRD: "SRD";
+        SSP: "SSP";
+        STN: "STN";
+        SVC: "SVC";
+        SYP: "SYP";
+        SZL: "SZL";
+        THB: "THB";
+        TJS: "TJS";
+        TMT: "TMT";
+        TND: "TND";
+        TOP: "TOP";
+        TRY: "TRY";
+        TTD: "TTD";
+        TWD: "TWD";
+        TZS: "TZS";
+        UAH: "UAH";
+        UGX: "UGX";
+        USD: "USD";
+        USN: "USN";
+        UYI: "UYI";
+        UYU: "UYU";
+        UYW: "UYW";
+        UZS: "UZS";
+        VES: "VES";
+        VND: "VND";
+        VUV: "VUV";
+        WST: "WST";
+        XAF: "XAF";
+        XAG: "XAG";
+        XAU: "XAU";
+        XBA: "XBA";
+        XBB: "XBB";
+        XBC: "XBC";
+        XBD: "XBD";
+        XCD: "XCD";
+        XDR: "XDR";
+        XOF: "XOF";
+        XPD: "XPD";
+        XPF: "XPF";
+        XPT: "XPT";
+        XSU: "XSU";
+        XTS: "XTS";
+        XUA: "XUA";
+        XXX: "XXX";
+        YER: "YER";
+        ZAR: "ZAR";
+        ZMW: "ZMW";
+        ZWL: "ZWL";
+    }>, zod.ZodNumber], null>;
 }

package/dist/cjs/Amount.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Amount = void 0;
 const isoly_1 = require("isoly");
 const isly_1 = require("isly");
+const zod_1 = require("./zod");
 var Amount;
 (function (Amount) {
     function toAmounts(amount) {
@@ -10,5 +11,6 @@ var Amount;
     }
     Amount.toAmounts = toAmounts;
     Amount.type = isly_1.isly.tuple(isly_1.isly.string(isoly_1.isoly.Currency.values), isly_1.isly.number());
+    Amount.typeZod = zod_1.zod.tuple([zod_1.zod.enum(isoly_1.isoly.Currency.values), zod_1.zod.number()]);
 })(Amount || (exports.Amount = Amount = {}));
 //# sourceMappingURL=Amount.js.map

package/dist/cjs/Amount.js.map

@@ -1 +1 @@
-{"version":3,"file":"Amount.js","sourceRoot":"","sources":["../../Amount.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAC7B,+BAA2B;AAK3B,IAAiB,MAAM,CAKtB;AALD,WAAiB,MAAM;IACtB,SAAgB,SAAS,CAAC,MAAe;QACxC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAS,CAAC,MAAM,CAAC,CAAC,CAAA;IAC3D,CAAC;IAFe,gBAAS,YAExB,CAAA;IACY,WAAI,GAAG,WAAI,CAAC,KAAK,CAAS,WAAI,CAAC,MAAM,CAAC,aAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAI,CAAC,MAAM,EAAE,CAAC,CAAA;AAC1F,CAAC,EALgB,MAAM,sBAAN,MAAM,QAKtB"}
+{"version":3,"file":"Amount.js","sourceRoot":"","sources":["../../Amount.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAC7B,+BAA2B;AAE3B,+BAA2B;AAI3B,IAAiB,MAAM,CAMtB;AAND,WAAiB,MAAM;IACtB,SAAgB,SAAS,CAAC,MAAe;QACxC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAS,CAAC,MAAM,CAAC,CAAC,CAAA;IAC3D,CAAC;IAFe,gBAAS,YAExB,CAAA;IACY,WAAI,GAAG,WAAI,CAAC,KAAK,CAAS,WAAI,CAAC,MAAM,CAAC,aAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAI,CAAC,MAAM,EAAE,CAAC,CAAA;IAC5E,cAAO,GAAG,SAAG,CAAC,KAAK,CAAC,CAAC,SAAG,CAAC,IAAI,CAAC,aAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;AAClF,CAAC,EANgB,MAAM,sBAAN,MAAM,QAMtB"}

package/dist/cjs/Balance.d.ts

@@ -33,15 +33,41 @@ export declare namespace Balance {
         namespace Entry {
             const values: readonly ["actual", "incomingReserved", "outgoingReserved", "bufferReserved"];
             const type: isly.Type<"actual" | "incomingReserved" | "outgoingReserved" | "bufferReserved">;
+            const typeZod: zod.ZodEnum<{
+                actual: "actual";
+                incomingReserved: "incomingReserved";
+                outgoingReserved: "outgoingReserved";
+                bufferReserved: "bufferReserved";
+            }>;
         }
         const type: isly.Type<Partial<Record<"actual" | "incomingReserved" | "outgoingReserved" | "bufferReserved", number>>>;
+        const typeZod: zod.ZodRecord<zod.ZodEnum<{
+            actual: "actual";
+            incomingReserved: "incomingReserved";
+            outgoingReserved: "outgoingReserved";
+            bufferReserved: "bufferReserved";
+        }> & zod.z.core.$partial, zod.ZodNumber>;
     }
     type MaybeLegacy = Balance | Legacy;
     namespace MaybeLegacy {
         const legacyType: isly.Type<MaybeLegacy>;
     }
     type Extended = Balance & Legacy;
-    const Extended: isly.Type<Extended>;
+    namespace Extended {
+        const type: isly.Type<Extended>;
+        const typeZod: zod.ZodObject<{
+            available: zod.ZodOptional<zod.ZodNumber>;
+            reserved: zod.ZodOptional<zod.ZodRecord<zod.ZodEnum<{
+                incoming: "incoming";
+                outgoing: "outgoing";
+                buffer: "buffer";
+            }> & zod.z.core.$partial, zod.ZodOptional<zod.ZodNumber>>>;
+            actual: zod.ZodOptional<zod.ZodNumber>;
+            incomingReserved: zod.ZodOptional<zod.ZodNumber>;
+            outgoingReserved: zod.ZodOptional<zod.ZodNumber>;
+            bufferReserved: zod.ZodOptional<zod.ZodNumber>;
+        }, zod.z.core.$strip>;
+    }
     function update(currency: isoly.Currency, balance: MaybeLegacy): Extended;
     function computeReserved(currency: isoly.Currency, balance: Balance): Amount;
     function computeActual(currency: isoly.Currency, balance: Balance): Amount;

package/dist/cjs/Balance.js

@@ -26,14 +26,25 @@ var Balance;
         (function (Entry) {
             Entry.values = ["actual", "incomingReserved", "outgoingReserved", "bufferReserved"];
             Entry.type = isly_1.isly.string(Entry.values);
+            Entry.typeZod = zod_1.zod.enum(Entry.values);
         })(Entry = Legacy.Entry || (Legacy.Entry = {}));
         Legacy.type = isly_1.isly.record(Entry.type, isly_1.isly.number());
+        Legacy.typeZod = zod_1.zod.partialRecord(Entry.typeZod, zod_1.zod.number());
     })(Legacy = Balance.Legacy || (Balance.Legacy = {}));
     let MaybeLegacy;
     (function (MaybeLegacy) {
         MaybeLegacy.legacyType = isly_1.isly.union(Balance.type, Legacy.type);
     })(MaybeLegacy = Balance.MaybeLegacy || (Balance.MaybeLegacy = {}));
-    Balance.Extended = isly_1.isly.intersection(Balance.type, Legacy.type);
+    let Extended;
+    (function (Extended) {
+        Extended.type = isly_1.isly.intersection(Balance.type, Legacy.type);
+        Extended.typeZod = Balance.typeZod.extend({
+            actual: zod_1.zod.number().optional(),
+            incomingReserved: zod_1.zod.number().optional(),
+            outgoingReserved: zod_1.zod.number().optional(),
+            bufferReserved: zod_1.zod.number().optional(),
+        });
+    })(Extended = Balance.Extended || (Balance.Extended = {}));
     function update(currency, balance) {
         const result = { ...balance };
         if (Legacy.type.is(balance)) {