@pax2pay/model-banking 0.1.491 → 0.1.493

package/Backup/Account.ts

@@ -0,0 +1,24 @@
+import { isoly } from "isoly"
+import { Account as modelAccount } from "../Account"
+import { Base } from "./Base"
+
+export interface Account extends Base<modelAccount> {
+	entityType: "account"
+	entity: string
+	organization: string
+	account: string
+	meta: { key: string }
+}
+export namespace Account {
+	export const create: Base.Create<modelAccount, Account> = (value: modelAccount, action: Base.Action) => ({
+		entityType: "account",
+		entity: value.id,
+		organization: value.organization,
+		account: value.id,
+		action,
+		created: isoly.DateTime.now(),
+		meta: { key: value.key ?? "" },
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/Base.ts

@@ -0,0 +1,32 @@
+import { isoly } from "isoly"
+import { Realm } from "../Realm"
+
+export type Base<T> = {
+	realm?: Realm
+	organization?: string
+	account?: string
+	entity: string
+	entityType: string
+	action: Base.Action
+	created: isoly.DateTime
+	isError?: true
+	meta?: any
+	value: T
+}
+export namespace Base {
+	export type Action = typeof Action.values[number]
+	export namespace Action {
+		export const values = ["created", "updated", "cancelled", "removed"] as const
+	}
+	export type Data = { realm?: Realm; organization?: string; account?: string; isError?: true; meta?: any }
+	export type Create<T, B extends Base<T>, D extends Data = Record<string, never>> = (...args: [T, Action, D?]) => B
+	export function pipeToSender<T, B extends Base<T>, D extends Data = Record<string, never>>(
+		mapper: Base.Create<T, B, D>
+	): (sender: (backup: B) => any | Promise<any>) => (...args: Parameters<typeof mapper>) => ReturnType<typeof sender> {
+		return sender =>
+			(...args) => {
+				const backup = mapper(...args)
+				return sender(backup)
+			}
+	}
+}

package/Backup/Card.ts

@@ -0,0 +1,25 @@
+import { isoly } from "isoly"
+import { Card as modelCard } from "../Card"
+import { Realm } from "../Realm"
+import { Base } from "./Base"
+
+export interface Card extends Base<modelCard> {
+	realm: Realm
+	entityType: "card"
+	entity: string
+	organization: string
+	account: string
+}
+export namespace Card {
+	export const create: Base.Create<modelCard, Card> = (value: modelCard, action: Base.Action) => ({
+		realm: value.realm,
+		entityType: "card",
+		entity: value.id,
+		organization: value.organization,
+		account: value.account,
+		action,
+		created: isoly.DateTime.now(),
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/Operation.ts

@@ -0,0 +1,25 @@
+import { isoly } from "isoly"
+import { Operation as modelOperation } from "../Operation"
+import { Base } from "./Base"
+
+export interface Operation extends Base<modelOperation> {
+	entityType: "operation"
+	entity: string
+	account: string
+}
+export namespace Operation {
+	export const create: Base.Create<modelOperation, Operation, { organization: string }> = (
+		value: modelOperation,
+		action: Base.Action,
+		data?: { organization: string }
+	) => ({
+		entityType: "operation",
+		entity: value.signature ?? "",
+		...data,
+		account: value.account,
+		action,
+		created: isoly.DateTime.now(),
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/Organization.ts

@@ -0,0 +1,26 @@
+import { isoly } from "isoly"
+import { Organization as modelOrganization } from "../Organization"
+import { Realm } from "../Realm"
+import { Base } from "./Base"
+
+export interface Organization extends Base<modelOrganization> {
+	realm: Realm
+	entityType: "organization"
+	entity: string
+	organization: string
+}
+export namespace Organization {
+	export const create: Base.Create<modelOrganization, Organization> = (
+		value: modelOrganization,
+		action: Base.Action
+	) => ({
+		realm: value.realm,
+		entityType: "organization",
+		entity: value.code,
+		organization: value.code,
+		action,
+		created: isoly.DateTime.now(),
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/Rule.ts

@@ -0,0 +1,25 @@
+import { isoly } from "isoly"
+import { Rule as modelRule } from "../Rule"
+import { Base } from "./Base"
+
+export interface Rule extends Base<modelRule> {
+	entityType: "rule"
+	entity: string
+	meta: string
+}
+export namespace Rule {
+	export const create: Base.Create<modelRule, Rule, { organization?: string; account?: string }> = (
+		value: modelRule,
+		action: Base.Action,
+		data?: { organization?: string; account?: string }
+	) => ({
+		entityType: "rule",
+		entity: value.code,
+		...data,
+		action,
+		created: isoly.DateTime.now(),
+		meta: `${value.category}.${value.type}.${value.action}`,
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/Transaction.ts

@@ -0,0 +1,28 @@
+import { isoly } from "isoly"
+import { Transaction as modelTransaction } from "../Transaction"
+import { Base } from "./Base"
+
+export interface Transaction extends Base<modelTransaction & { state?: any }> {
+	entityType: "transaction"
+	entity: string
+	organization: string
+	account: string
+	isError?: true
+}
+export namespace Transaction {
+	export const create: Base.Create<modelTransaction & { state?: any }, Transaction, { isError?: true; meta?: any }> = (
+		value: modelTransaction & { state?: any },
+		action: Base.Action,
+		data?: { isError?: true; meta?: any }
+	) => ({
+		entityType: "transaction",
+		entity: value.id,
+		organization: value.organization,
+		account: value.accountId,
+		action,
+		...data,
+		created: isoly.DateTime.now(),
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/User.ts

@@ -0,0 +1,25 @@
+import { isoly } from "isoly"
+import { userwidgets } from "@userwidgets/model"
+import { Realm } from "../Realm"
+import { Base } from "./Base"
+
+export type User = Base<userwidgets.User> & {
+	entityType: "user"
+	entity: string
+}
+
+export namespace User {
+	export const create: Base.Create<userwidgets.User, User, { realm: Realm }> = (
+		value: userwidgets.User,
+		action: Base.Action,
+		data?: { realm: Realm }
+	) => ({
+		...data,
+		entityType: "user",
+		entity: value.email,
+		action,
+		created: isoly.DateTime.now(),
+		value,
+	})
+	export const addSender = Base.pipeToSender(create)
+}

package/Backup/index.ts

@@ -0,0 +1,30 @@
+import { Realm } from "../Realm"
+import { Account as AccountBackup } from "./Account"
+import { Base as BaseBackup } from "./Base"
+import { Card as CardBackup } from "./Card"
+import { Operation as OperationBackup } from "./Operation"
+import { Organization as OrganizationBackup } from "./Organization"
+import { Rule as RuleBackup } from "./Rule"
+import { Transaction as TransactionBackup } from "./Transaction"
+import { User as UserBackup } from "./User"
+
+export type Backup = Backup.Partial & Backup.Identifier
+export namespace Backup {
+	export type Identifier = { realm: Realm; version: string; source: string }
+	export type Partial =
+		| TransactionBackup
+		| OperationBackup
+		| OrganizationBackup
+		| RuleBackup
+		| AccountBackup
+		| CardBackup
+		| UserBackup
+	export import Base = BaseBackup
+	export import Transaction = TransactionBackup
+	export import Account = AccountBackup
+	export import Organization = OrganizationBackup
+	export import Rule = RuleBackup
+	export import Operation = OperationBackup
+	export import User = UserBackup
+	export import Card = CardBackup
+}

package/Card/Meta.ts

@@ -1,6 +1,5 @@
-type Value = Meta | Value[] | undefined | number | string | boolean
 export interface Meta {
-	[key: string]: Value
+	[key: string]: any
 }
 
 export namespace Meta {

package/Operation/Changes.ts

@@ -100,10 +100,7 @@ export namespace Changes {
 			export const type = isly.string<Balance>(values)
 		}
 	}
-	export function fromCapture(
-		settlement: string | undefined, // FIXME: remove | undefined when we're sure we send the id
-		amounts: { net: number; fee: number; charge?: number }
-	): Changes {
+	export function fromCapture(settlement: string, amounts: { net: number; fee: number; charge?: number }): Changes {
 		return {
 			[`${settlement}-net`]: { type: "add" as const, amount: amounts.net, status: "pending" as const },
 			[`${settlement}-fee`]: { type: "add" as const, amount: amounts.fee, status: "pending" as const },
@@ -113,7 +110,7 @@ export namespace Changes {
 		}
 	}
 	export function fromRefund(
-		settlement: string | undefined, // FIXME: remove | undefined when we're sure we send the id
+		settlement: string,
 		refund: Settlement.Entry.Creatable.Refund,
 		charge: number | undefined,
 		sum: Sum

package/Rule/Reserve.ts

@@ -21,10 +21,7 @@ export namespace Reserve {
 	}
 	export const type = Base.type.extend<Reserve>({
 		action: isly.string(Action.value),
-		reserve: isly.object({
-			percentage: isly.number(),
-			fixed: Amount.type.optional(),
-		}),
+		reserve: isly.object({ percentage: isly.number(), fixed: Amount.type.optional() }),
 	})
 
 	export interface Api extends Base {
@@ -63,11 +60,7 @@ export namespace Reserve {
 		macros?: Record<string, selectively.Definition>,
 		table: Exchange.Rates = {}
 	): { outcomes: Reserve[]; notes: Note[]; reserve: number } {
-		const result: ReturnType<typeof evaluate> = {
-			outcomes: [],
-			notes: [],
-			reserve: 0,
-		}
+		const result: ReturnType<typeof evaluate> = { outcomes: [], notes: [], reserve: 0 }
 		const now = isoly.DateTime.now()
 		if (
 			state.transaction.stage == "initiate" &&

package/Rule/State/Transaction.ts

@@ -13,7 +13,6 @@ export type Transaction = ModelTransaction.Creatable.Resolved & {
 		total: number
 		amount: number
 		charge?: { current: number; total: number }
-		reserve?: number
 	}
 }
 export namespace Transaction {
@@ -31,7 +30,7 @@ export namespace Transaction {
 							transaction.currency,
 							transaction.state?.transaction.original.total ??
 								(typeof transaction.amount == "number" ? transaction.amount : transaction.amount.total),
-							stage === "finalize" ? transaction.state?.transaction.original.reserve ?? 0 : 0
+							stage === "finalize" ? transaction.state?.transaction.original.charge?.total ?? 0 : 0
 						),
 				  ]
 				: [transaction.amount, transaction.amount]

package/Rule/index.ts

@@ -2,6 +2,7 @@ import { selectively } from "selectively"
 import { isly } from "isly"
 import { Exchange } from "../Exchange"
 import { Realm } from "../Realm"
+import type { Note } from "../Transaction/Note"
 import { Base as RuleBase } from "./Base"
 import { Charge as RuleCharge } from "./Charge"
 import { control as ruleControl } from "./control"
@@ -63,30 +64,32 @@ export namespace Rule {
 			score: [],
 			reserve: [],
 		}
+		const notes: Note[] = []
 		const { other, chargers, scorers, reservers } = sort(rules, state)
 		const scored = Score.evaluate(scorers, state, macros)
+		notes.push(...scored.notes)
 		outcomes.score.push(...scored.outcomes)
 		state.transaction.risk = scored.risk
 		const evaluated = Other.evaluate(other, state, macros)
+		notes.push(...evaluated.notes)
 		outcomes.flag.push(...evaluated.outcomes.flag)
 		outcomes.review.push(...evaluated.outcomes.review)
 		outcomes.reject.push(...evaluated.outcomes.reject)
-		const reserved = Reserve.evaluate(reservers, state, macros, table)
-		outcomes.reserve.push(...reserved.outcomes)
-		state.transaction.original.reserve = reserved.reserve
-		state.transaction.original.total = Reserve.apply(reserved.reserve, state)
-		const charged = Charge.evaluate(chargers, state, macros, table)
-		outcomes.charge.push(...charged.outcomes)
-		state.transaction.original.charge = charged.charge
-		state.transaction.original.total = Charge.apply(charged.charge, state)
-		const outcome = outcomes.reject.length > 0 ? "reject" : outcomes.review.length > 0 ? "review" : "approve"
-		return {
-			...state,
-			flags: [...evaluated.flags],
-			notes: [...scored.notes, ...evaluated.notes, ...reserved.notes, ...charged.notes],
-			outcomes,
-			outcome,
+		if (state.transaction.stage == "initiate") {
+			const reserved = Reserve.evaluate(reservers, state, macros, table)
+			state.transaction.original.charge = { current: reserved.reserve, total: reserved.reserve }
+			state.transaction.original.total = Reserve.apply(reserved.reserve, state)
+			outcomes.reserve.push(...reserved.outcomes)
+			notes.push(...reserved.notes)
+		} else if (state.transaction.stage == "finalize") {
+			const charged = Charge.evaluate(chargers, state, macros, table)
+			outcomes.charge.push(...charged.outcomes)
+			state.transaction.original.charge = charged.charge
+			state.transaction.original.total = Charge.apply(charged.charge, state)
+			notes.push(...charged.notes)
 		}
+		const outcome = outcomes.reject.length > 0 ? "reject" : outcomes.review.length > 0 ? "review" : "approve"
+		return { ...state, flags: [...evaluated.flags], notes, outcomes, outcome }
 	}
 	function sort(
 		rules: Rule[],

package/Transaction/Amount.ts

@@ -0,0 +1,41 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import type { Rule } from "../Rule"
+import { Exchange } from "./Exchange"
+
+export interface Amount {
+	original: number
+	charge: number
+	total: number
+	exchange?: Exchange
+}
+export namespace Amount {
+	export const type = isly.object<Amount>({
+		original: isly.number(),
+		charge: isly.number(),
+		total: isly.number(),
+		exchange: Exchange.type.optional(),
+	})
+	export function fromState(state: Rule.State): Amount {
+		const sign = ["outbound", "authorization", "capture"].some(direction => direction == state.transaction.kind)
+			? -1
+			: 1
+		return {
+			original: sign * state.transaction.original.amount,
+			charge: sign * (state.transaction.original.charge?.total ?? 0),
+			total: sign * state.transaction.original.total,
+			exchange: state?.transaction.exchange ?? state.authorization?.exchange,
+		}
+	}
+
+	export function change(
+		currency: isoly.Currency,
+		amount: Amount,
+		change: number,
+		type: Exclude<keyof Amount, "total" | "exchange">
+	): Amount {
+		amount[type] = isoly.Currency.add(currency, amount[type], change)
+		amount.total = isoly.Currency.add(currency, amount.total, change)
+		return amount
+	}
+}

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 { Amount as TransactionAmount } from "./Amount"
 import { Creatable as TransactionCreatable } from "./Creatable"
 import { Exchange as TransactionExchange } from "./Exchange"
 import { Note as TransactionNote } from "./Note"
@@ -44,58 +45,7 @@ export interface Transaction {
 }
 export namespace Transaction {
 	export import Exchange = TransactionExchange
-	export type Amount = { original: number; reserved: number; charge: number; total: number; exchange?: Exchange }
-	export namespace Amount {
-		export const type = isly.object<Amount>({
-			original: isly.number(),
-			reserved: isly.number(),
-			charge: isly.number(),
-			total: isly.number(),
-			exchange: Exchange.type.optional(),
-		})
-		export function fromState(state: Rule.State): Amount {
-			const sign = ["outbound", "authorization", "capture"].some(direction => direction == state.transaction.kind)
-				? -1
-				: 1
-			return {
-				original: sign * state.transaction.original.amount,
-				reserved: sign * (state.transaction.original.reserve ?? 0),
-				charge: sign * (state.transaction.original.charge?.total ?? 0),
-				total: sign * state.transaction.original.total,
-				exchange: state?.transaction.exchange ?? state.authorization?.exchange,
-			}
-		}
-		export function fromOperations(
-			transaction: Transaction | Transaction.Creatable,
-			operations: Operation[],
-			state?: Rule.State
-		): Amount {
-			const stateAmount = state && fromState(state)
-			const changes = Operation.sum(operations)
-			const reserved = isoly.Currency.add(
-				transaction.currency,
-				changes["reserved-incoming"] ?? 0,
-				changes["reserved-outgoing"] ?? 0
-			)
-			return {
-				original: typeof transaction.amount == "number" ? transaction.amount : transaction.amount.original,
-				reserved,
-				charge: stateAmount?.charge ?? 0,
-				total: changes.available ?? reserved ?? 0,
-				exchange: state?.transaction.exchange ?? state?.authorization?.exchange,
-			}
-		}
-		export function change(
-			currency: isoly.Currency,
-			amount: Amount,
-			change: number,
-			type: Exclude<keyof Amount, "total" | "exchange">
-		): Amount {
-			amount[type] = isoly.Currency.add(currency, amount[type], change)
-			amount.total = isoly.Currency.add(currency, amount.total, change)
-			return amount
-		}
-	}
+	export import Amount = TransactionAmount
 	export const types = ["card", "internal", "external", "system"] as const
 	export type Types = typeof types[number]
 	export const directions = ["inbound", "outbound"] as const
@@ -137,7 +87,25 @@ export namespace Transaction {
 		risk: isly.number().optional(),
 		state: isly.any().optional(),
 	})
-
+	export function amountFromOperations(
+		transaction: Transaction | Transaction.Creatable,
+		operations: Operation[],
+		state?: Rule.State
+	): Amount {
+		const stateAmount = state && Amount.fromState(state)
+		const changes = Operation.sum(operations)
+		const reserved = isoly.Currency.add(
+			transaction.currency,
+			changes["reserved-incoming"] ?? 0,
+			changes["reserved-outgoing"] ?? 0
+		)
+		return {
+			original: typeof transaction.amount == "number" ? transaction.amount : transaction.amount.original,
+			charge: stateAmount?.charge ?? 0,
+			total: changes.available ?? reserved ?? 0,
+			exchange: state?.transaction.exchange ?? state?.authorization?.exchange,
+		}
+	}
 	export interface Legacy extends Omit<Transaction, "amount"> {
 		amount: number
 	}
@@ -154,7 +122,6 @@ export namespace Transaction {
 								transaction.state?.transaction.original.amount ??
 								isoly.Currency.subtract(transaction.currency, transaction.amount, transaction.charge ?? 0),
 							charge: transaction.state?.transaction.original.charge?.total ?? transaction.charge ?? 0,
-							reserved: transaction.state?.transaction.original.reserve ?? 0,
 							total: transaction.state?.transaction.original.total ?? transaction.amount,
 						},
 				  }
@@ -232,7 +199,7 @@ export namespace Transaction {
 	): Transaction {
 		return {
 			...creatable,
-			amount: { original: creatable.amount, reserved: 0, charge: 0, total: creatable.amount },
+			amount: { original: creatable.amount, charge: 0, total: creatable.amount },
 			type: getType(creatable.counterpart, account.name),
 			direction: "inbound",
 			organization: account.organization,
@@ -258,7 +225,7 @@ export namespace Transaction {
 	): Transaction {
 		return {
 			...creatable,
-			amount: { original: 0, reserved: 0, charge: 0, total: 0 },
+			amount: { original: 0, charge: 0, total: 0 },
 			type: getType(creatable.counterpart, account.name),
 			direction: "inbound",
 			organization: account.organization,
@@ -292,7 +259,7 @@ export namespace Transaction {
 				name: account.name,
 				organization: account.organization,
 			},
-			amount: { original: 0, reserved: 0, charge: 0, total: 0 },
+			amount: { original: 0, charge: 0, total: 0 },
 			type: "internal",
 			direction: "inbound",
 			organization: account.organization,

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

@@ -0,0 +1,15 @@
+import { Account as modelAccount } from "../Account";
+import { Base } from "./Base";
+export interface Account extends Base<modelAccount> {
+    entityType: "account";
+    entity: string;
+    organization: string;
+    account: string;
+    meta: {
+        key: string;
+    };
+}
+export declare namespace Account {
+    const create: Base.Create<modelAccount, Account>;
+    const addSender: (sender: (backup: Account) => any | Promise<any>) => (args_0: modelAccount, args_1: "created" | "cancelled" | "updated" | "removed", args_2?: Record<string, never> | undefined) => ReturnType<(backup: Account) => any | Promise<any>>;
+}

package/dist/cjs/Backup/Account.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+const isoly_1 = require("isoly");
+const Base_1 = require("./Base");
+var Account;
+(function (Account) {
+    Account.create = (value, action) => ({
+        entityType: "account",
+        entity: value.id,
+        organization: value.organization,
+        account: value.id,
+        action,
+        created: isoly_1.isoly.DateTime.now(),
+        meta: { key: value.key ?? "" },
+        value,
+    });
+    Account.addSender = Base_1.Base.pipeToSender(Account.create);
+})(Account || (exports.Account = Account = {}));
+//# sourceMappingURL=Account.js.map

package/dist/cjs/Backup/Account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Account.js","sourceRoot":"","sources":["../../../Backup/Account.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAE7B,iCAA6B;AAS7B,IAAiB,OAAO,CAYvB;AAZD,WAAiB,OAAO;IACV,cAAM,GAAuC,CAAC,KAAmB,EAAE,MAAmB,EAAE,EAAE,CAAC,CAAC;QACxG,UAAU,EAAE,SAAS;QACrB,MAAM,EAAE,KAAK,CAAC,EAAE;QAChB,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,OAAO,EAAE,KAAK,CAAC,EAAE;QACjB,MAAM;QACN,OAAO,EAAE,aAAK,CAAC,QAAQ,CAAC,GAAG,EAAE;QAC7B,IAAI,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,EAAE,EAAE;QAC9B,KAAK;KACL,CAAC,CAAA;IACW,iBAAS,GAAG,WAAI,CAAC,YAAY,CAAC,QAAA,MAAM,CAAC,CAAA;AACnD,CAAC,EAZgB,OAAO,uBAAP,OAAO,QAYvB"}

package/dist/cjs/Backup/Base.d.ts

@@ -0,0 +1,29 @@
+import { isoly } from "isoly";
+import { Realm } from "../Realm";
+export type Base<T> = {
+    realm?: Realm;
+    organization?: string;
+    account?: string;
+    entity: string;
+    entityType: string;
+    action: Base.Action;
+    created: isoly.DateTime;
+    isError?: true;
+    meta?: any;
+    value: T;
+};
+export declare namespace Base {
+    type Action = typeof Action.values[number];
+    namespace Action {
+        const values: readonly ["created", "updated", "cancelled", "removed"];
+    }
+    type Data = {
+        realm?: Realm;
+        organization?: string;
+        account?: string;
+        isError?: true;
+        meta?: any;
+    };
+    type Create<T, B extends Base<T>, D extends Data = Record<string, never>> = (...args: [T, Action, D?]) => B;
+    function pipeToSender<T, B extends Base<T>, D extends Data = Record<string, never>>(mapper: Base.Create<T, B, D>): (sender: (backup: B) => any | Promise<any>) => (...args: Parameters<typeof mapper>) => ReturnType<typeof sender>;
+}

package/dist/cjs/Backup/Base.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+var Base;
+(function (Base) {
+    let Action;
+    (function (Action) {
+        Action.values = ["created", "updated", "cancelled", "removed"];
+    })(Action = Base.Action || (Base.Action = {}));
+    function pipeToSender(mapper) {
+        return sender => (...args) => {
+            const backup = mapper(...args);
+            return sender(backup);
+        };
+    }
+    Base.pipeToSender = pipeToSender;
+})(Base || (exports.Base = Base = {}));
+//# sourceMappingURL=Base.js.map

package/dist/cjs/Backup/Base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base.js","sourceRoot":"","sources":["../../../Backup/Base.ts"],"names":[],"mappings":";;;AAeA,IAAiB,IAAI,CAgBpB;AAhBD,WAAiB,IAAI;IAEpB,IAAiB,MAAM,CAEtB;IAFD,WAAiB,MAAM;QACT,aAAM,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,CAAU,CAAA;IAC9E,CAAC,EAFgB,MAAM,GAAN,WAAM,KAAN,WAAM,QAEtB;IAGD,SAAgB,YAAY,CAC3B,MAA4B;QAE5B,OAAO,MAAM,CAAC,EAAE,CACf,CAAC,GAAG,IAAI,EAAE,EAAE;YACX,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;YAC9B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAA;QACtB,CAAC,CAAA;IACH,CAAC;IARe,iBAAY,eAQ3B,CAAA;AACF,CAAC,EAhBgB,IAAI,oBAAJ,IAAI,QAgBpB"}

package/dist/cjs/Backup/Card.d.ts

@@ -0,0 +1,14 @@
+import { Card as modelCard } from "../Card";
+import { Realm } from "../Realm";
+import { Base } from "./Base";
+export interface Card extends Base<modelCard> {
+    realm: Realm;
+    entityType: "card";
+    entity: string;
+    organization: string;
+    account: string;
+}
+export declare namespace Card {
+    const create: Base.Create<modelCard, Card>;
+    const addSender: (sender: (backup: Card) => any | Promise<any>) => (args_0: modelCard, args_1: "created" | "cancelled" | "updated" | "removed", args_2?: Record<string, never> | undefined) => ReturnType<(backup: Card) => any | Promise<any>>;
+}