@pax2pay/model-banking 0.1.490 → 0.1.492

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/Rule/State/Transaction.ts

@@ -48,4 +48,23 @@ export namespace Transaction {
 			},
 		}
 	}
+	export function fromPreTransaction(
+		accountName: string,
+		transaction: ModelTransaction.PreTransaction | ModelTransaction,
+		kind: Rule.Base.Kind,
+		stage: "finalize" | "initiate"
+	): Transaction {
+		return {
+			...transaction,
+			stage,
+			kind,
+			amount: Math.abs(typeof transaction.amount == "number" ? transaction.amount : transaction.amount.total),
+			type: ModelTransaction.getType(transaction.counterpart, accountName),
+			original: {
+				currency: transaction.currency,
+				amount: Math.abs(typeof transaction.amount == "number" ? transaction.amount : transaction.amount.original),
+				total: Math.abs(typeof transaction.amount == "number" ? transaction.amount : transaction.amount.total),
+			},
+		}
+	}
 }

package/Rule/State/index.ts

@@ -1,5 +1,6 @@
 import { isly } from "isly"
 import { Account as ModelAccount } from "../../Account"
+import type { Card as ModelCard } from "../../Card"
 import { Rail } from "../../Rail"
 import type { Transaction as ModelTransaction } from "../../Transaction"
 import type { Rule } from "../index"
@@ -59,4 +60,27 @@ export namespace State {
 			organization,
 		}
 	}
+	export const type: Record<ModelTransaction.PreTransaction["type"], Rule.Base.Kind> = {
+		authorization: "authorization",
+		incoming: "inbound",
+		outgoing: "outbound",
+	}
+	export function fromPreTransaction(
+		data: Data,
+		account: ModelAccount,
+		address: Rail.Address,
+		transactions: Account.Transactions,
+		days: Account.Days,
+		transaction: ModelTransaction.PreTransaction,
+		card?: ModelCard & { statistics: Card.Statistics },
+		organization?: Organization
+	): State {
+		return {
+			data,
+			account: Account.from(account, address, transactions, days),
+			transaction: Transaction.from(account.name, transaction, type[transaction.type], "initiate"),
+			card: card ? Card.from(card, card.statistics) : undefined,
+			organization,
+		}
+	}
 }

package/Transaction/PreTransaction/Authorization.ts

@@ -0,0 +1,20 @@
+import { isly } from "isly"
+import { Rail } from "../../Rail"
+import { Base } from "./Base"
+
+export interface Authorization extends Base {
+	type: "authorization"
+	account: Pick<Rail.Address.Card, "id" | "type">
+	counterpart: Rail.Address.Card.Counterpart
+	reference: { reference: string }
+	approvalCode?: string
+}
+export namespace Authorization {
+	export const type = Base.type.extend<Authorization>({
+		type: isly.string("authorization"),
+		account: Rail.Address.Card.type.pick(["id", "type"]),
+		counterpart: Rail.Address.Card.Counterpart.type,
+		reference: isly.object<{ reference: string }>({ reference: isly.string() }),
+		approvalCode: isly.string().optional(),
+	})
+}

package/Transaction/PreTransaction/Base.ts

@@ -0,0 +1,23 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Rail } from "../../Rail"
+import { Exchange } from "../Exchange"
+
+export interface Base {
+	type: "outgoing" | "incoming" | "authorization"
+	counterpart: Rail.Address
+	currency: isoly.Currency
+	amount: number
+	description: string
+	exchange?: Exchange
+}
+export namespace Base {
+	export const type = isly.object<Base>({
+		type: isly.string(["outgoing", "incoming", "authorization"]),
+		counterpart: Rail.Address.type,
+		currency: isly.fromIs("isoly.Currency", isoly.Currency.is),
+		amount: isly.number(),
+		description: isly.string(),
+		exchange: Exchange.type.optional(),
+	})
+}

package/Transaction/PreTransaction/Incoming.ts

@@ -0,0 +1,42 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Rail } from "../../Rail"
+import { Settlement } from "../../Settlement"
+import { Reference as TransactionReference } from "../Reference"
+import { Base } from "./Base"
+
+export interface Incoming extends Base {
+	type: "incoming"
+	account: Rail.Address
+	currency: isoly.Currency
+	amount: number
+	description: string
+	posted: string
+	rail?: Rail
+	reference?: TransactionReference
+}
+export namespace Incoming {
+	export const type = Base.type.extend<Incoming>({
+		type: isly.string("incoming"),
+		account: Rail.Address.type,
+		currency: isly.fromIs("Currency", isoly.Currency.is),
+		amount: isly.number(),
+		description: isly.string(),
+		posted: isly.string(),
+		rail: Rail.type.optional(),
+		reference: TransactionReference.type.optional(),
+	})
+	export function fromRefund(entry: Settlement.Entry.Creatable.Refund, card: Rail.Address.Card): Incoming {
+		const [currency, amount] = entry.amount
+		return {
+			type: "incoming",
+			account: card,
+			currency,
+			amount: isoly.Currency.add(currency, -amount, -(entry.fee.other[currency] ?? 0)),
+			posted: isoly.DateTime.now(),
+			counterpart: { type: "card", merchant: entry.merchant, acquirer: entry.acquirer },
+			description: "Refund transaction.",
+			rail: card.scheme,
+		}
+	}
+}

package/Transaction/PreTransaction/Outgoing.ts

@@ -0,0 +1,8 @@
+import type { Base } from "./Base"
+
+export interface Outgoing extends Base {
+	type: "outgoing"
+}
+export namespace Outgoing {
+	export const dummy = true
+}

package/Transaction/PreTransaction/index.ts

@@ -0,0 +1,16 @@
+import { Rail } from "../../Rail"
+import { Authorization as PreTransactionAuthorization } from "./Authorization"
+import { Incoming as PreTransactionIncoming } from "./Incoming"
+import { Outgoing as PreTransactionOutgoing } from "./Outgoing"
+
+export type PreTransaction = PreTransaction.Outgoing | PreTransaction.Authorization | PreTransaction.Incoming
+export namespace PreTransaction {
+	export type Resolved =
+		| (PreTransaction & { counterpart: Rail.Address; type: "outgoing" })
+		| PreTransaction.Incoming
+		| PreTransaction.Authorization
+
+	export import Authorization = PreTransactionAuthorization
+	export import Incoming = PreTransactionIncoming
+	export import Outgoing = PreTransactionOutgoing
+}

package/Transaction/index.ts

@@ -9,11 +9,12 @@ import type { Rule } from "../Rule"
 import { Settlement } from "../Settlement"
 import { Creatable as TransactionCreatable } from "./Creatable"
 import { Exchange as TransactionExchange } from "./Exchange"
-import { Incoming as TransactionIncoming } from "./Incoming"
 import { Note as TransactionNote } from "./Note"
+import { PreTransaction as TransactionPreTransaction } from "./PreTransaction"
 import { Reference as TransactionReference } from "./Reference"
 import { Statistics as TransactionStatistics } from "./Statistics"
 import { Status as TransactionStatus } from "./Status"
+
 export interface Transaction {
 	counterpart: Rail.Address & { code?: string }
 	currency: isoly.Currency
@@ -100,7 +101,7 @@ export namespace Transaction {
 	export const directions = ["inbound", "outbound"] as const
 	export type Direction = typeof directions[number]
 	export import Creatable = TransactionCreatable
-	export import Incoming = TransactionIncoming
+	export import PreTransaction = TransactionPreTransaction
 	export import Reference = TransactionReference
 	export import Note = TransactionNote
 	export import Status = TransactionStatus
@@ -311,7 +312,7 @@ export namespace Transaction {
 		}
 	}
 	export function fromIncoming(
-		transaction: Transaction.Incoming,
+		transaction: Transaction.PreTransaction.Incoming,
 		id: string,
 		state: Rule.State.Evaluated,
 		account: { id: string; name: string; organization: string },
@@ -347,7 +348,7 @@ export namespace Transaction {
 		state: Rule.State.Evaluated
 	): Transaction {
 		return {
-			...Incoming.fromRefund(refund, card),
+			...Transaction.PreTransaction.Incoming.fromRefund(refund, card),
 			amount: Amount.fromState(state),
 			type: "card",
 			direction: "inbound",

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>>;
+}

package/dist/cjs/Backup/Card.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Card.js","sourceRoot":"","sources":["../../../Backup/Card.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAG7B,iCAA6B;AAS7B,IAAiB,IAAI,CAYpB;AAZD,WAAiB,IAAI;IACP,WAAM,GAAiC,CAAC,KAAgB,EAAE,MAAmB,EAAE,EAAE,CAAC,CAAC;QAC/F,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,UAAU,EAAE,MAAM;QAClB,MAAM,EAAE,KAAK,CAAC,EAAE;QAChB,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,MAAM;QACN,OAAO,EAAE,aAAK,CAAC,QAAQ,CAAC,GAAG,EAAE;QAC7B,KAAK;KACL,CAAC,CAAA;IACW,cAAS,GAAG,WAAI,CAAC,YAAY,CAAC,KAAA,MAAM,CAAC,CAAA;AACnD,CAAC,EAZgB,IAAI,oBAAJ,IAAI,QAYpB"}

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

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

package/dist/cjs/Backup/Operation.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Operation.js","sourceRoot":"","sources":["../../../Backup/Operation.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAE7B,iCAA6B;AAO7B,IAAiB,SAAS,CAezB;AAfD,WAAiB,SAAS;IACZ,gBAAM,GAAqE,CACvF,KAAqB,EACrB,MAAmB,EACnB,IAA+B,EAC9B,EAAE,CAAC,CAAC;QACL,UAAU,EAAE,WAAW;QACvB,MAAM,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE;QAC7B,GAAG,IAAI;QACP,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,MAAM;QACN,OAAO,EAAE,aAAK,CAAC,QAAQ,CAAC,GAAG,EAAE;QAC7B,KAAK;KACL,CAAC,CAAA;IACW,mBAAS,GAAG,WAAI,CAAC,YAAY,CAAC,UAAA,MAAM,CAAC,CAAA;AACnD,CAAC,EAfgB,SAAS,yBAAT,SAAS,QAezB"}