@pax2pay/model-banking 0.1.567 → 0.1.569

package/Account/Charge/Fx/index.ts

@@ -0,0 +1,29 @@
+import { isoly } from "isoly"
+import { Card } from "../../../Card"
+import { Amount } from "../../../Transaction/Amount"
+import { Exchange } from "../../../Transaction/Exchange"
+import { Preset } from "../Preset"
+
+export type Fx = Preset
+
+export namespace Fx {
+	export const type = Preset.type
+	export function evaluate(
+		charge: Fx,
+		currency: isoly.Currency,
+		amount: number,
+		preset?: Card.Preset,
+		exchange?: Exchange
+	): Amount.Charge.Fx | undefined {
+		let result: Amount.Charge.Fx | undefined
+		const chargePreset = preset && charge[preset] ? preset : "default"
+		const chargeRate = charge[chargePreset] ?? 0
+		if (exchange)
+			result = {
+				preset: chargePreset,
+				rate: chargeRate,
+				amount: -isoly.Currency.multiply(currency, amount, chargeRate),
+			}
+		return result
+	}
+}

package/Account/Charge/Merchant/index.ts

@@ -0,0 +1,42 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Card } from "../../../Card"
+import { Rail } from "../../../Rail"
+import { Amount } from "../../../Transaction/Amount"
+import { Preset } from "../Preset"
+
+export interface Merchant {
+	destination: { account: string }
+	merchants: Partial<Record<Card.Restriction.Merchant, Preset>>
+}
+export namespace Merchant {
+	export const type = isly.object<Merchant>({
+		destination: isly.object({
+			account: isly.string(),
+		}),
+		merchants: isly.record<Card.Restriction.Merchant, Preset>(Card.Restriction.Merchant.type, Preset.type),
+	})
+
+	export function evaluate(
+		charge: Merchant,
+		currency: isoly.Currency,
+		amount: number,
+		counterpart: Rail.Address.Card.Counterpart,
+		preset?: Card.Preset
+	): Amount.Charge.Merchant | undefined {
+		let result: Amount.Charge.Merchant | undefined
+		const merchant = Card.Restriction.Merchant.resolve(counterpart)
+		if (merchant) {
+			const chargePreset = preset && charge.merchants?.[merchant]?.[preset] ? preset : "default"
+			const chargeRate = charge.merchants?.[merchant]?.[chargePreset] ?? 0
+			result = {
+				merchant,
+				preset: chargePreset,
+				destination: charge.destination,
+				rate: chargeRate,
+				amount: -isoly.Currency.multiply(currency, amount, chargeRate),
+			}
+		}
+		return result
+	}
+}

package/Account/Charge/Preset/index.ts

@@ -0,0 +1,15 @@
+import { isly } from "isly"
+import { Card } from "../../../Card"
+
+export type Preset = Partial<Record<Card.Preset, number>> & {
+	default: number
+}
+
+export namespace Preset {
+	const recordType = isly.record<Preset>(isly.string(Card.Preset.names), isly.number())
+	const defaultType = isly.object<{ default: number }>({ default: isly.number() })
+	function is(value: unknown): value is Preset {
+		return defaultType.is(value) && recordType.is((({ default: _, ...rest }) => rest)(value))
+	}
+	export const type = isly.fromIs("Preset", is)
+}

package/Account/Charge/index.ts

@@ -1,58 +1,31 @@
-import { cryptly } from "cryptly"
 import { isoly } from "isoly"
 import { isly } from "isly"
 import type { Card } from "../../Card"
 import type { Rail } from "../../Rail"
 import type { Transaction } from "../../Transaction"
-import { Applies } from "./Applies"
+import { Fx as ChargeFx } from "./Fx"
+import { Merchant as ChargeMerchant } from "./Merchant"
 
-export interface Charge extends Charge.Creatable {
-	id: string
-}
+export type Charge = { merchant?: Charge.Merchant; fx?: Charge.Fx }
 export namespace Charge {
-	export interface Creatable {
-		destination: { account: string }
-		rate: number // rate: 0.01 for 1%
-		applies: Applies
-	}
-	export namespace Creatable {
-		export const type = isly.object<Creatable>({
-			destination: isly.object({ account: isly.string() }),
-			rate: isly.number(),
-			applies: Applies.type,
-		})
-	}
-	export const type = Creatable.type.extend<Charge>({
-		id: isly.string(),
-	})
-	export function fromCreatable(creatable: Creatable): Charge {
-		return { ...creatable, id: cryptly.Identifier.generate(4) }
-	}
+	export import Merchant = ChargeMerchant
+	export import Fx = ChargeFx
+	export const type = isly.object<Charge>({ merchant: ChargeMerchant.type, fx: ChargeFx.type })
 	export function evaluate(
-		charges: Charge[] = [],
 		counterpart: Rail.Address.Card.Counterpart,
 		currency: isoly.Currency,
 		amount: number,
 		preset?: Card.Preset,
+		charges?: Charge,
 		exchange?: Transaction.Exchange
-	): Transaction.Amount.Charge[] {
-		const result: Transaction.Amount.Charge[] = []
-		for (const charge of charges)
-			if (Applies.evaluate(charge.applies, counterpart, preset, exchange))
-				result.push(toTransactionAmountCharge(currency, amount, charge))
-		return result
-	}
-	function toTransactionAmountCharge(
-		currency: isoly.Currency,
-		amount: number,
-		charge: Charge
 	): Transaction.Amount.Charge {
+		const merchant =
+			charges?.merchant && ChargeMerchant.evaluate(charges.merchant, currency, amount, counterpart, preset)
+		const fx = charges?.fx && ChargeFx.evaluate(charges.fx, currency, amount, preset, exchange)
+
 		return {
-			amount: -isoly.Currency.multiply(currency, amount, charge.rate),
-			charge,
+			...(merchant && { merchant }),
+			...(fx && { fx }),
 		}
 	}
-	export function sum(charges: Transaction.Amount.Charge[], currency: isoly.Currency): number {
-		return charges.reduce((sum, charge) => isoly.Currency.add(currency, sum, charge.amount), 0)
-	}
 }

package/Account/index.ts

@@ -19,7 +19,7 @@ export interface Account extends Account.Creatable {
 	details?: Account.Details
 	counterparts?: Record<string, Rail.Address>
 	key?: string
-	charges?: AccountCharge[]
+	charges?: AccountCharge
 	rules?: Rule[]
 	status: Account.Status
 }
@@ -42,7 +42,7 @@ export namespace Account {
 		details: Details.type.optional(),
 		counterparts: isly.record<Record<string, Rail.Address>>(isly.string(), Rail.Address.type).optional(),
 		key: isly.string().optional(),
-		charges: AccountCharge.type.array().optional(),
+		charges: AccountCharge.type.optional(),
 		rules: Rule.type.array().optional(),
 		status: AccountStatus.type,
 	})

package/Authorization/index.ts

@@ -5,7 +5,6 @@ import { Acquirer } from "../Acquirer"
 import { Amount } from "../Amount"
 import { Merchant } from "../Merchant"
 import { Transaction } from "../Transaction"
-import { Exchange as AuthorizationExchange } from "./Exchange"
 import { Status as AuthorizationStatus } from "./Status"
 
 export interface Authorization {
@@ -15,7 +14,7 @@ export interface Authorization {
 	reference: string
 	approvalCode?: string
 	amount: Amount
-	exchange?: AuthorizationExchange
+	exchange?: Transaction.Exchange
 	card: {
 		id: string
 		token?: string
@@ -33,7 +32,6 @@ export interface Authorization {
 	description: string
 }
 export namespace Authorization {
-	export import Exchange = AuthorizationExchange
 	export import Status = AuthorizationStatus
 	export const type = isly.object<Authorization>({
 		id: isly.fromIs("Authorization.id", cryptly.Identifier.is),
@@ -45,7 +43,7 @@ export namespace Authorization {
 				description: isly.string(),
 			})
 			.optional(),
-		exchange: AuthorizationExchange.type.optional(),
+		exchange: Transaction.Exchange.type.optional(),
 		card: isly.object<Authorization["card"]>({
 			id: isly.string(),
 			token: isly.string().optional(),

package/Card/Restriction/Merchant.ts

@@ -27,4 +27,13 @@ export namespace Merchant {
 			result = false
 		return result
 	}
+	export function resolve(counterpart: Rail.Address.Card.Counterpart): Merchant | undefined {
+		let result: Merchant | undefined
+		for (const merchant of values)
+			if (check(merchant, counterpart)) {
+				result = merchant
+				break
+			}
+		return result
+	}
 }

package/Client/Accounts/Charge.ts

@@ -4,17 +4,13 @@ import { Account } from "../../Account"
 
 export class Charge {
 	constructor(private readonly client: http.Client) {}
-	async create(account: string, charge: Account.Charge.Creatable): Promise<Account.Charge | gracely.Error> {
+	async create(account: string, charge: Account.Charge): Promise<Account.Charge | gracely.Error> {
 		return this.client.post<Account.Charge>(`/account/${account}/charge`, charge)
 	}
 	async remove(account: string, id: string): Promise<Account.Charge | gracely.Error> {
 		return this.client.delete<Account.Charge>(`/account/${account}/charge/${id}`)
 	}
-	async replace(
-		account: string,
-		id: string,
-		charge: Account.Charge.Creatable
-	): Promise<Account.Charge | gracely.Error> {
+	async replace(account: string, id: string, charge: Account.Charge): Promise<Account.Charge | gracely.Error> {
 		return this.client.put<Account.Charge>(`/account/${account}/charge/${id}`, charge)
 	}
 }

package/Rule/State/Authorization.ts

@@ -1,7 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Acquirer } from "../../Acquirer"
-import { Exchange } from "../../Authorization/Exchange"
 import { Merchant } from "../../Merchant"
 import { Rail } from "../../Rail"
 import type { Transaction } from "../../Transaction"
@@ -9,7 +8,7 @@ import type { Transaction } from "../../Transaction"
 export interface Authorization {
 	card: string
 	account: string
-	exchange?: Exchange
+	exchange?: Transaction.Exchange
 	acquirer: Acquirer
 	description: string
 	approvalCode?: string
@@ -62,7 +61,7 @@ export namespace Authorization {
 	export const type = isly.object<Authorization>({
 		card: isly.string(),
 		account: isly.string(),
-		exchange: Exchange.type.optional(),
+		exchange: isly.any().optional(),
 		acquirer: Acquirer.type,
 		description: isly.string(),
 		approvalCode: isly.string().optional(),

package/Settlement/Entry/index.ts

@@ -25,17 +25,17 @@ export namespace Entry {
 	export const type = entryType
 	export const from = fromCreatable
 	export function charge(
-		charges: Account.Charge[] = [],
 		counterpart: Rail.Address.Card.Counterpart,
 		capture: Creatable.Capture,
-		preset?: Preset
-	): Transaction.Amount.Charge[] {
+		preset?: Preset,
+		charges?: Account.Charge
+	): Transaction.Amount.Charge {
 		return Account.Charge.evaluate(
-			charges,
 			counterpart,
 			capture.amount[0],
 			isoly.Currency.add(capture.amount[0], capture.amount[1], capture.fee.other[capture.amount[0]] ?? 0),
 			preset,
+			charges,
 			capture.exchange
 		)
 	}

package/Transaction/Amount/Charge/index.ts

@@ -0,0 +1,86 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Card } from "../../../Card"
+import { Rail } from "../../../Rail"
+import { PreTransaction } from "../../PreTransaction"
+
+export interface Charge {
+	merchant?: Charge.Merchant
+	fx?: Charge.Fx
+}
+export namespace Charge {
+	export interface Fx {
+		amount: number
+		rate: number
+		preset: Card.Preset | "default"
+	}
+	export namespace Fx {
+		export const type = isly.object<Fx>({
+			amount: isly.number(),
+			rate: isly.number(),
+			preset: isly.union(Card.Preset.type, isly.string("default")),
+		})
+	}
+	export interface Merchant {
+		amount: number
+		rate: number
+		merchant: Card.Restriction.Merchant
+		preset: Card.Preset | "default"
+		destination: { account: string }
+	}
+	export namespace Merchant {
+		export const type = isly.object<Merchant>({
+			amount: isly.number(),
+			rate: isly.number(),
+			merchant: Card.Restriction.Merchant.type,
+			preset: isly.union(Card.Preset.type, isly.string("default")),
+			destination: isly.object({
+				account: isly.string(),
+			}),
+		})
+	}
+	export type ChargeTransaction = PreTransaction.Incoming & { counterpart: Rail.Address.Internal }
+	export function total(currency: isoly.Currency, charges: Charge): number {
+		return isoly.Currency.add(currency, charges.fx?.amount ?? 0, charges.merchant?.amount ?? 0)
+	}
+	export function toTransactions(
+		charge: Charge,
+		account: string,
+		id: string,
+		currency: isoly.Currency,
+		fxCollectAccount: string
+	): {
+		merchant: ChargeTransaction | undefined
+		fx: ChargeTransaction | undefined
+	} {
+		const merchant =
+			charge.merchant && toTransaction(charge.merchant, account, id, currency, fxCollectAccount, "merchant")
+		const fx = charge.fx && toTransaction(charge.fx, account, id, currency, fxCollectAccount, "fx")
+		return { merchant, fx }
+	}
+	function toTransaction(
+		charge: Charge.Merchant | Charge.Fx,
+		account: string,
+		id: string,
+		currency: isoly.Currency,
+		fxCollectAccount: string,
+		type: "merchant" | "fx"
+	): ChargeTransaction {
+		const accountId = Merchant.type.is(charge) ? charge.destination.account : fxCollectAccount
+		return {
+			type: "incoming",
+			account: { type: "internal", identifier: accountId },
+			counterpart: { type: "internal", identifier: account },
+			currency: currency,
+			amount: charge.amount,
+			description: `${type} charge for transaction ${id}`,
+			posted: isoly.DateTime.now(),
+			rail: "internal",
+			reference: { reference: id, returnId: id },
+		}
+	}
+	export const type = isly.object<Charge>({
+		merchant: Charge.Merchant.type.optional(),
+		fx: Charge.Fx.type.optional(),
+	})
+}

package/Transaction/{Amount.ts → Amount/index.ts}

@@ -1,47 +1,39 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { Charge as AccountCharge } from "../Account/Charge"
-import type { Rule } from "../Rule"
-import { Exchange } from "./Exchange"
+import type { Rule } from "../../Rule"
+import { Exchange } from "../Exchange"
+import { Charge as AmountCharge } from "./Charge"
 
 export interface Amount {
 	original: number
 	charge: number //Legacy
-	charges?: Amount.Charge[]
+	charges?: Amount.Charge
 	total: number
 	exchange?: Exchange
 }
 export namespace Amount {
-	export interface Charge {
-		amount: number
-		charge: AccountCharge
-	}
-	export namespace Charge {
-		export const type = isly.object<Charge>({
-			amount: isly.number(),
-			charge: AccountCharge.type,
-		})
-		export function total(currency: isoly.Currency, charges: Charge[] = []): number {
-			return charges.reduce((r, c) => isoly.Currency.add(currency, r, c.amount), 0)
-		}
-	}
+	export import Charge = AmountCharge
 	export const type = isly.object<Amount>({
 		original: isly.number(),
 		charge: isly.number(),
-		charges: Charge.type.array().optional(),
+		charges: Amount.Charge.type.optional(),
 		total: isly.number(),
 		exchange: Exchange.type.optional(),
 	})
-	export function fromState(state: Rule.State, charges?: Charge[]): Amount {
+	export function fromState(state: Rule.State, charges?: Charge): Amount {
 		const sign = ["outbound", "authorization", "capture"].some(direction => direction == state.transaction.kind)
 			? -1
 			: 1
-		const charge = Amount.Charge.total(state.transaction.original.currency, charges)
+
 		return {
 			original: sign * state.transaction.original.amount,
 			charge: 0,
 			charges,
-			total: isoly.Currency.add(state.transaction.original.currency, sign * state.transaction.original.total, charge),
+			total: isoly.Currency.add(
+				state.transaction.original.currency,
+				sign * state.transaction.original.total,
+				Amount.Charge.total(state.transaction.original.currency, charges ?? {})
+			),
 			exchange: state?.transaction.exchange ?? state.authorization?.exchange,
 		}
 	}

package/Transaction/Creatable.ts

@@ -37,13 +37,13 @@ export namespace Creatable {
 			reference: isly.object<{ reference: string }>({ reference: isly.string() }),
 			approvalCode: isly.string().optional(),
 		})
-		export function charge(charges: Account.Charge[], creatable: CardTransaction, preset?: Preset): Amount.Charge[] {
+		export function charge(creatable: CardTransaction, preset: Preset, charges?: Account.Charge): Amount.Charge {
 			return Account.Charge.evaluate(
-				charges,
 				creatable.counterpart,
 				creatable.currency,
 				creatable.amount,
 				preset,
+				charges,
 				creatable.exchange
 			)
 		}

package/Transaction/Exchange.ts

@@ -3,11 +3,15 @@ import { Amount } from "../Amount"
 
 export interface Exchange {
 	rate: number
-	from: Amount
+	to?: Amount
+	from?: Amount
+	quote?: string
 }
 export namespace Exchange {
 	export const type = isly.object<Exchange>({
 		rate: isly.number(),
-		from: Amount.type,
+		to: Amount.type.optional(),
+		from: Amount.type.optional(),
+		quote: isly.string().optional(),
 	})
 }

package/Transaction/index.ts

@@ -89,7 +89,7 @@ export namespace Transaction {
 	export function amountFromOperations(
 		transaction: Transaction,
 		operations: Operation[],
-		charges?: Amount.Charge[]
+		charges?: Amount.Charge
 	): Amount {
 		const changes = Operation.sum(operations)
 		const reserved = isoly.Currency.add(
@@ -148,8 +148,8 @@ export namespace Transaction {
 		account: { id: string; name: string; organization: string; address: Rail.Address },
 		balance: { actual: number; reserved: number; available: number },
 		operation: Operation | Status.Reason,
-		charges: Amount.Charge[],
-		by: string | undefined
+		charges?: Amount.Charge,
+		by?: string
 	): Transaction {
 		const status: Status =
 			typeof operation == "string"

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

@@ -0,0 +1,10 @@
+import { isoly } from "isoly";
+import { Card } from "../../../Card";
+import { Amount } from "../../../Transaction/Amount";
+import { Exchange } from "../../../Transaction/Exchange";
+import { Preset } from "../Preset";
+export type Fx = Preset;
+export declare namespace Fx {
+    const type: import("isly/dist/cjs/Type").Type<Preset>;
+    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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fx = void 0;
+const isoly_1 = require("isoly");
+const Preset_1 = require("../Preset");
+var Fx;
+(function (Fx) {
+    Fx.type = Preset_1.Preset.type;
+    function evaluate(charge, currency, amount, preset, exchange) {
+        let result;
+        const chargePreset = preset && charge[preset] ? preset : "default";
+        const chargeRate = charge[chargePreset] ?? 0;
+        if (exchange)
+            result = {
+                preset: chargePreset,
+                rate: chargeRate,
+                amount: -isoly_1.isoly.Currency.multiply(currency, amount, chargeRate),
+            };
+        return result;
+    }
+    Fx.evaluate = evaluate;
+})(Fx || (exports.Fx = Fx = {}));
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Fx/index.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAI7B,sCAAkC;AAIlC,IAAiB,EAAE,CAoBlB;AApBD,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;YACX,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,OAAO,MAAM,CAAA;IACd,CAAC;IAjBe,WAAQ,WAiBvB,CAAA;AACF,CAAC,EApBgB,EAAE,kBAAF,EAAE,QAoBlB"}

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

@@ -0,0 +1,15 @@
+import { isoly } from "isoly";
+import { Card } from "../../../Card";
+import { Rail } from "../../../Rail";
+import { Amount } from "../../../Transaction/Amount";
+import { Preset } from "../Preset";
+export interface Merchant {
+    destination: {
+        account: string;
+    };
+    merchants: Partial<Record<Card.Restriction.Merchant, Preset>>;
+}
+export declare namespace Merchant {
+    const type: import("isly/dist/cjs/object").IslyObject<Merchant, object>;
+    function evaluate(charge: Merchant, currency: isoly.Currency, amount: number, counterpart: Rail.Address.Card.Counterpart, preset?: Card.Preset): Amount.Charge.Merchant | undefined;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Merchant = void 0;
+const isoly_1 = require("isoly");
+const isly_1 = require("isly");
+const Card_1 = require("../../../Card");
+const Preset_1 = require("../Preset");
+var Merchant;
+(function (Merchant) {
+    Merchant.type = isly_1.isly.object({
+        destination: isly_1.isly.object({
+            account: isly_1.isly.string(),
+        }),
+        merchants: isly_1.isly.record(Card_1.Card.Restriction.Merchant.type, Preset_1.Preset.type),
+    });
+    function evaluate(charge, currency, amount, counterpart, preset) {
+        let result;
+        const merchant = Card_1.Card.Restriction.Merchant.resolve(counterpart);
+        if (merchant) {
+            const chargePreset = preset && charge.merchants?.[merchant]?.[preset] ? preset : "default";
+            const chargeRate = charge.merchants?.[merchant]?.[chargePreset] ?? 0;
+            result = {
+                merchant,
+                preset: chargePreset,
+                destination: charge.destination,
+                rate: chargeRate,
+                amount: -isoly_1.isoly.Currency.multiply(currency, amount, chargeRate),
+            };
+        }
+        return result;
+    }
+    Merchant.evaluate = evaluate;
+})(Merchant || (exports.Merchant = Merchant = {}));
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Merchant/index.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAC7B,+BAA2B;AAC3B,wCAAoC;AAGpC,sCAAkC;AAMlC,IAAiB,QAAQ,CA8BxB;AA9BD,WAAiB,QAAQ;IACX,aAAI,GAAG,WAAI,CAAC,MAAM,CAAW;QACzC,WAAW,EAAE,WAAI,CAAC,MAAM,CAAC;YACxB,OAAO,EAAE,WAAI,CAAC,MAAM,EAAE;SACtB,CAAC;QACF,SAAS,EAAE,WAAI,CAAC,MAAM,CAAoC,WAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAM,CAAC,IAAI,CAAC;KACtG,CAAC,CAAA;IAEF,SAAgB,QAAQ,CACvB,MAAgB,EAChB,QAAwB,EACxB,MAAc,EACd,WAA0C,EAC1C,MAAoB;QAEpB,IAAI,MAA0C,CAAA;QAC9C,MAAM,QAAQ,GAAG,WAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;QAC/D,IAAI,QAAQ,EAAE,CAAC;YACd,MAAM,YAAY,GAAG,MAAM,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAA;YAC1F,MAAM,UAAU,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;YACpE,MAAM,GAAG;gBACR,QAAQ;gBACR,MAAM,EAAE,YAAY;gBACpB,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,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;IArBe,iBAAQ,WAqBvB,CAAA;AACF,CAAC,EA9BgB,QAAQ,wBAAR,QAAQ,QA8BxB"}

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

@@ -0,0 +1,8 @@
+import { isly } from "isly";
+import { Card } from "../../../Card";
+export type Preset = Partial<Record<Card.Preset, number>> & {
+    default: number;
+};
+export declare namespace Preset {
+    const type: isly.Type<Preset>;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Preset = void 0;
+const isly_1 = require("isly");
+const Card_1 = require("../../../Card");
+var Preset;
+(function (Preset) {
+    const recordType = isly_1.isly.record(isly_1.isly.string(Card_1.Card.Preset.names), isly_1.isly.number());
+    const defaultType = isly_1.isly.object({ default: isly_1.isly.number() });
+    function is(value) {
+        return defaultType.is(value) && recordType.is((({ default: _, ...rest }) => rest)(value));
+    }
+    Preset.type = isly_1.isly.fromIs("Preset", is);
+})(Preset || (exports.Preset = Preset = {}));
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../Account/Charge/Preset/index.ts"],"names":[],"mappings":";;;AAAA,+BAA2B;AAC3B,wCAAoC;AAMpC,IAAiB,MAAM,CAOtB;AAPD,WAAiB,MAAM;IACtB,MAAM,UAAU,GAAG,WAAI,CAAC,MAAM,CAAS,WAAI,CAAC,MAAM,CAAC,WAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,WAAI,CAAC,MAAM,EAAE,CAAC,CAAA;IACrF,MAAM,WAAW,GAAG,WAAI,CAAC,MAAM,CAAsB,EAAE,OAAO,EAAE,WAAI,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IAChF,SAAS,EAAE,CAAC,KAAc;QACzB,OAAO,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;IAC1F,CAAC;IACY,WAAI,GAAG,WAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAA;AAC9C,CAAC,EAPgB,MAAM,sBAAN,MAAM,QAOtB"}