@mnemopay/sdk 0.2.0 → 0.4.0

package/dist/index.js

@@ -11,10 +11,12 @@
  *   MnemoPay.create({...})   → Postgres + Redis (production)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.l2Normalize = exports.localEmbed = exports.cosineSimilarity = exports.RecallEngine = exports.MnemoPay = exports.MnemoPayLite = void 0;
+exports.BehaviorProfile = exports.TransactionGraph = exports.IsolationForest = exports.DEFAULT_RATE_LIMIT = exports.DEFAULT_FRAUD_CONFIG = exports.RateLimiter = exports.FraudGuard = exports.l2Normalize = exports.localEmbed = exports.cosineSimilarity = exports.RecallEngine = exports.MnemoPay = exports.MnemoPayLite = void 0;
 exports.autoScore = autoScore;
 exports.computeScore = computeScore;
+exports.reputationTier = reputationTier;
 const engine_js_1 = require("./recall/engine.js");
+const fraud_js_1 = require("./fraud.js");
 class EventEmitter {
     _events = new Map();
     on(event, fn) {
@@ -50,6 +52,17 @@ class EventEmitter {
 function randomUUID() {
     return crypto.randomUUID();
 }
+function reputationTier(score) {
+    if (score >= 0.9)
+        return "exemplary";
+    if (score >= 0.7)
+        return "trusted";
+    if (score >= 0.4)
+        return "established";
+    if (score >= 0.2)
+        return "newcomer";
+    return "untrusted";
+}
 // ─── Auto-scoring keywords ─────────────────────────────────────────────────
 const IMPORTANCE_PATTERNS = [
     { pattern: /\b(error|fail|crash|critical|broken|bug)\b/i, boost: 0.20 },
@@ -87,15 +100,123 @@ class MnemoPayLite extends EventEmitter {
     _wallet = 0;
     _reputation = 0.5;
     recallEngine;
-    constructor(agentId, decay = 0.05, debug = false, recallConfig) {
+    _createdAt = new Date();
+    x402;
+    persistPath;
+    persistTimer;
+    /** Fraud detection, rate limiting, dispute resolution, and platform fee */
+    fraud;
+    constructor(agentId, decay = 0.05, debug = false, recallConfig, fraudConfig) {
         super();
         this.agentId = agentId;
         this.decay = decay;
         this.debugMode = debug;
         this.recallEngine = new engine_js_1.RecallEngine(recallConfig);
-        this.log(`MnemoPayLite initialized (in-memory mode, recall: ${this.recallEngine.strategy})`);
+        this.fraud = new fraud_js_1.FraudGuard(fraudConfig);
+        // Auto-detect persistence: MNEMOPAY_PERSIST_DIR env var or explicit enablePersistence()
+        const persistDir = typeof process !== "undefined" ? process.env?.MNEMOPAY_PERSIST_DIR : undefined;
+        if (persistDir) {
+            this.enablePersistence(persistDir);
+        }
+        this.log(`MnemoPayLite initialized (${this.persistPath ? "persistent" : "in-memory"} mode, recall: ${this.recallEngine.strategy})`);
         setTimeout(() => this.emit("ready"), 0);
     }
+    // ── Persistence ────────────────────────────────────────────────────────
+    enablePersistence(dir) {
+        try {
+            const fs = require("fs");
+            const path = require("path");
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            this.persistPath = path.join(dir, `${this.agentId}.json`);
+            this._loadFromDisk();
+            // Auto-save every 30 seconds
+            this.persistTimer = setInterval(() => this._saveToDisk(), 30_000);
+            this.log(`Persistence enabled: ${this.persistPath}`);
+        }
+        catch (e) {
+            this.log(`Persistence unavailable (browser?): ${e}`);
+        }
+    }
+    _loadFromDisk() {
+        if (!this.persistPath)
+            return;
+        try {
+            const fs = require("fs");
+            if (!fs.existsSync(this.persistPath))
+                return;
+            const raw = JSON.parse(fs.readFileSync(this.persistPath, "utf-8"));
+            // Restore memories
+            if (raw.memories) {
+                for (const m of raw.memories) {
+                    m.createdAt = new Date(m.createdAt);
+                    m.lastAccessed = new Date(m.lastAccessed);
+                    this.memories.set(m.id, m);
+                }
+            }
+            // Restore transactions
+            if (raw.transactions) {
+                for (const t of raw.transactions) {
+                    t.createdAt = new Date(t.createdAt);
+                    if (t.completedAt)
+                        t.completedAt = new Date(t.completedAt);
+                    this.transactions.set(t.id, t);
+                }
+            }
+            // Restore state
+            if (raw.wallet !== undefined)
+                this._wallet = raw.wallet;
+            if (raw.reputation !== undefined)
+                this._reputation = raw.reputation;
+            if (raw.createdAt)
+                this._createdAt = new Date(raw.createdAt);
+            if (raw.auditLog) {
+                this.auditLog = raw.auditLog.map((e) => ({ ...e, createdAt: new Date(e.createdAt) }));
+            }
+            // Restore fraud guard state
+            if (raw.fraudGuard) {
+                try {
+                    const restored = fraud_js_1.FraudGuard.deserialize(raw.fraudGuard, this.fraud.config);
+                    // Copy restored state into existing guard (preserve config from constructor)
+                    Object.assign(this.fraud, {
+                    // Only copy internal state, not config
+                    });
+                    // Re-create fraud guard with restored data
+                    const restoredGuard = fraud_js_1.FraudGuard.deserialize(raw.fraudGuard, this.fraud.config);
+                    this.fraud = restoredGuard;
+                }
+                catch (e) {
+                    this.log(`Failed to restore fraud guard state: ${e}`);
+                }
+            }
+            this.log(`Loaded ${this.memories.size} memories, ${this.transactions.size} transactions from disk`);
+        }
+        catch (e) {
+            this.log(`Failed to load persisted data: ${e}`);
+        }
+    }
+    _saveToDisk() {
+        if (!this.persistPath)
+            return;
+        try {
+            const fs = require("fs");
+            const data = JSON.stringify({
+                agentId: this.agentId,
+                wallet: this._wallet,
+                reputation: this._reputation,
+                createdAt: this._createdAt.toISOString(),
+                memories: Array.from(this.memories.values()),
+                transactions: Array.from(this.transactions.values()),
+                auditLog: this.auditLog.slice(-500), // Keep last 500 entries
+                fraudGuard: this.fraud.serialize(),
+                savedAt: new Date().toISOString(),
+            });
+            fs.writeFileSync(this.persistPath, data, "utf-8");
+        }
+        catch (e) {
+            this.log(`Failed to persist data: ${e}`);
+        }
+    }
     log(msg) {
         if (this.debugMode)
             console.log(`[mnemopay:${this.agentId}] ${msg}`);
@@ -131,6 +252,7 @@ class MnemoPayLite extends EventEmitter {
             await this.recallEngine.embed(mem.id, content);
         }
         this.audit("memory:stored", { id: mem.id, content: content.slice(0, 100), importance: mem.importance });
+        this._saveToDisk();
         this.emit("memory:stored", { id: mem.id, content, importance: mem.importance });
         this.log(`Stored memory: "${content.slice(0, 60)}..." (importance: ${mem.importance.toFixed(2)})`);
         return mem.id;
@@ -173,6 +295,7 @@ class MnemoPayLite extends EventEmitter {
         if (existed) {
             this.recallEngine.remove(id);
             this.audit("memory:deleted", { id });
+            this._saveToDisk();
             this.log(`Forgot memory: ${id}`);
         }
         return existed;
@@ -184,6 +307,7 @@ class MnemoPayLite extends EventEmitter {
         mem.importance = Math.min(mem.importance + boost, 1.0);
         mem.lastAccessed = new Date();
         this.audit("memory:reinforced", { id, boost, newImportance: mem.importance });
+        this._saveToDisk();
         this.log(`Reinforced memory ${id} by +${boost} → ${mem.importance.toFixed(2)}`);
     }
     async consolidate() {
@@ -201,11 +325,12 @@ class MnemoPayLite extends EventEmitter {
         // Clean up embedding cache for pruned memories
         this.recallEngine.removeBatch(prunedIds);
         this.audit("memory:consolidated", { pruned });
+        this._saveToDisk();
         this.log(`Consolidated: pruned ${pruned} stale memories`);
         return pruned;
     }
     // ── Payment Methods ─────────────────────────────────────────────────────
-    async charge(amount, reason) {
+    async charge(amount, reason, ctx) {
         if (amount <= 0)
             throw new Error("Amount must be positive");
         const maxCharge = 500 * this._reputation;
@@ -213,6 +338,21 @@ class MnemoPayLite extends EventEmitter {
             throw new Error(`Amount $${amount.toFixed(2)} exceeds reputation ceiling $${maxCharge.toFixed(2)} ` +
                 `(reputation: ${this._reputation.toFixed(2)}, max: $${maxCharge.toFixed(2)})`);
         }
+        // ── Fraud check ──────────────────────────────────────────────────────
+        const pendingCount = Array.from(this.transactions.values()).filter((t) => t.status === "pending").length;
+        const risk = this.fraud.assessCharge(this.agentId, amount, this._reputation, this._createdAt, pendingCount, ctx);
+        if (!risk.allowed) {
+            this.audit("fraud:blocked", { amount, reason, riskScore: risk.score, signals: risk.signals.map((s) => s.type) });
+            this._saveToDisk();
+            this.emit("fraud:blocked", { amount, risk });
+            throw new Error(risk.reason || `Charge blocked: risk score ${risk.score}`);
+        }
+        if (risk.flagged) {
+            this.audit("fraud:flagged", { amount, reason, riskScore: risk.score, signals: risk.signals.map((s) => s.type) });
+            this.emit("fraud:flagged", { amount, risk });
+        }
+        // Record charge for velocity tracking
+        this.fraud.recordCharge(this.agentId, amount, ctx);
         const tx = {
             id: randomUUID(),
             agentId: this.agentId,
@@ -220,11 +360,13 @@ class MnemoPayLite extends EventEmitter {
             reason,
             status: "pending",
             createdAt: new Date(),
+            riskScore: risk.score,
         };
         this.transactions.set(tx.id, tx);
-        this.audit("payment:pending", { id: tx.id, amount, reason });
+        this.audit("payment:pending", { id: tx.id, amount, reason, riskScore: risk.score });
+        this._saveToDisk();
         this.emit("payment:pending", { id: tx.id, amount, reason });
-        this.log(`Charge created: $${amount.toFixed(2)} for "${reason}" (pending)`);
+        this.log(`Charge created: $${amount.toFixed(2)} for "${reason}" (pending, risk: ${risk.score})`);
         return { ...tx };
     }
     async settle(txId) {
@@ -233,13 +375,17 @@ class MnemoPayLite extends EventEmitter {
             throw new Error(`Transaction ${txId} not found`);
         if (tx.status !== "pending")
             throw new Error(`Transaction ${txId} is ${tx.status}, not pending`);
-        // 1. Move funds to wallet
+        // 1. Apply platform fee
+        const fee = this.fraud.applyPlatformFee(tx.id, this.agentId, tx.amount);
+        tx.platformFee = fee.feeAmount;
+        tx.netAmount = fee.netAmount;
+        // 2. Move NET funds to wallet (after fee)
         tx.status = "completed";
         tx.completedAt = new Date();
-        this._wallet += tx.amount;
-        // 2. Boost reputation
+        this._wallet += fee.netAmount;
+        // 3. Boost reputation
         this._reputation = Math.min(this._reputation + 0.01, 1.0);
-        // 3. Reinforce recently-accessed memories (feedback loop)
+        // 4. Reinforce recently-accessed memories (feedback loop)
         const oneHourAgo = Date.now() - 3_600_000;
         let reinforced = 0;
         for (const mem of this.memories.values()) {
@@ -248,10 +394,14 @@ class MnemoPayLite extends EventEmitter {
                 reinforced++;
             }
         }
-        this.audit("payment:completed", { id: tx.id, amount: tx.amount, reinforcedMemories: reinforced });
-        this.emit("payment:completed", { id: tx.id, amount: tx.amount });
-        this.log(`Settled $${tx.amount.toFixed(2)} → wallet: $${this._wallet.toFixed(2)}, ` +
-            `reputation: ${this._reputation.toFixed(2)}, reinforced: ${reinforced} memories`);
+        this.audit("payment:completed", {
+            id: tx.id, grossAmount: tx.amount, platformFee: fee.feeAmount,
+            netAmount: fee.netAmount, feeRate: fee.feeRate, reinforcedMemories: reinforced,
+        });
+        this._saveToDisk();
+        this.emit("payment:completed", { id: tx.id, amount: fee.netAmount, fee: fee.feeAmount });
+        this.log(`Settled $${tx.amount.toFixed(2)} (fee: $${fee.feeAmount.toFixed(2)}, net: $${fee.netAmount.toFixed(2)}) → ` +
+            `wallet: $${this._wallet.toFixed(2)}, reputation: ${this._reputation.toFixed(2)}, reinforced: ${reinforced} memories`);
         return { ...tx };
     }
     async refund(txId) {
@@ -261,15 +411,58 @@ class MnemoPayLite extends EventEmitter {
         if (tx.status === "refunded")
             throw new Error(`Transaction ${txId} already refunded`);
         if (tx.status === "completed") {
-            this._wallet = Math.max(this._wallet - tx.amount, 0);
+            // Refund the net amount (platform fee is NOT refunded)
+            const refundAmount = tx.netAmount ?? tx.amount;
+            this._wallet = Math.max(this._wallet - refundAmount, 0);
             this._reputation = Math.max(this._reputation - 0.05, 0);
         }
         tx.status = "refunded";
-        this.audit("payment:refunded", { id: tx.id, amount: tx.amount });
+        this.audit("payment:refunded", { id: tx.id, amount: tx.amount, netRefunded: tx.netAmount ?? tx.amount });
+        this._saveToDisk();
         this.emit("payment:refunded", { id: tx.id });
         this.log(`Refunded $${tx.amount.toFixed(2)} → reputation: ${this._reputation.toFixed(2)}`);
         return { ...tx };
     }
+    // ── Dispute Resolution ─────────────────────────────────────────────────
+    async dispute(txId, reason, evidence) {
+        const tx = this.transactions.get(txId);
+        if (!tx)
+            throw new Error(`Transaction ${txId} not found`);
+        if (tx.status !== "completed")
+            throw new Error(`Can only dispute completed transactions (current: ${tx.status})`);
+        if (!tx.completedAt)
+            throw new Error(`Transaction ${txId} has no completion date`);
+        const d = this.fraud.fileDispute(txId, this.agentId, reason, tx.completedAt, evidence);
+        tx.status = "disputed";
+        this.audit("payment:disputed", { id: tx.id, disputeId: d.id, reason });
+        this._saveToDisk();
+        this.emit("payment:disputed", { txId, disputeId: d.id, reason });
+        this.log(`Dispute filed for tx ${txId}: ${reason}`);
+        return d;
+    }
+    async resolveDispute(disputeId, outcome) {
+        const d = this.fraud.resolveDispute(disputeId, outcome);
+        if (outcome === "refund") {
+            const tx = this.transactions.get(d.txId);
+            if (tx && tx.status === "disputed") {
+                const refundAmount = tx.netAmount ?? tx.amount;
+                this._wallet = Math.max(this._wallet - refundAmount, 0);
+                this._reputation = Math.max(this._reputation - 0.05, 0);
+                tx.status = "refunded";
+            }
+        }
+        else {
+            const tx = this.transactions.get(d.txId);
+            if (tx && tx.status === "disputed") {
+                tx.status = "completed"; // Restore to completed
+            }
+        }
+        this.audit("dispute:resolved", { disputeId, outcome, txId: d.txId });
+        this._saveToDisk();
+        this.emit("dispute:resolved", { disputeId, outcome });
+        this.log(`Dispute ${disputeId} resolved: ${outcome}`);
+        return d;
+    }
     async balance() {
         return { wallet: this._wallet, reputation: this._reputation };
     }
@@ -292,8 +485,93 @@ class MnemoPayLite extends EventEmitter {
         all.reverse();
         return all.slice(0, limit).map((tx) => ({ ...tx }));
     }
+    // ── Reputation ──────────────────────────────────────────────────────────
+    async reputation() {
+        const txs = Array.from(this.transactions.values());
+        const settled = txs.filter((t) => t.status === "completed");
+        const refunded = txs.filter((t) => t.status === "refunded");
+        const totalCompleted = settled.length + refunded.length;
+        const settlementRate = totalCompleted > 0 ? settled.length / totalCompleted : 0;
+        const totalValueSettled = settled.reduce((sum, t) => sum + t.amount, 0);
+        const mems = Array.from(this.memories.values());
+        const avgImportance = mems.length > 0
+            ? mems.reduce((sum, m) => sum + m.importance, 0) / mems.length
+            : 0;
+        const ageHours = (Date.now() - this._createdAt.getTime()) / 3_600_000;
+        const report = {
+            agentId: this.agentId,
+            score: this._reputation,
+            tier: reputationTier(this._reputation),
+            settledCount: settled.length,
+            refundCount: refunded.length,
+            settlementRate,
+            totalValueSettled,
+            memoriesCount: this.memories.size,
+            avgMemoryImportance: Math.round(avgImportance * 100) / 100,
+            ageHours: Math.round(ageHours * 10) / 10,
+            generatedAt: new Date(),
+        };
+        this.log(`Reputation: ${report.tier} (${report.score.toFixed(2)}), ${report.settledCount} settled, rate: ${(report.settlementRate * 100).toFixed(0)}%`);
+        return report;
+    }
+    // ── A2A Agent Card ─────────────────────────────────────────────────────
+    agentCard(url, contact) {
+        return {
+            name: `MnemoPay Agent (${this.agentId})`,
+            description: "AI agent with persistent cognitive memory and micropayment capabilities via MnemoPay protocol.",
+            url,
+            version: "0.2.0",
+            capabilities: {
+                memory: true,
+                payments: true,
+                reputation: true,
+            },
+            protocols: ["mcp", "a2a"],
+            tools: [
+                "remember", "recall", "forget", "reinforce", "consolidate",
+                "charge", "settle", "refund", "balance", "profile",
+                "reputation", "logs", "history",
+            ],
+            contact,
+        };
+    }
+    // ── x402 Settlement ────────────────────────────────────────────────────
+    configureX402(config) {
+        this.x402 = config;
+        this.log(`x402 configured: ${config.facilitatorUrl} (${config.token || "USDC"} on ${config.chain || "base"})`);
+    }
+    async settleViaX402(txId) {
+        if (!this.x402)
+            throw new Error("x402 not configured. Call configureX402() first.");
+        const tx = this.transactions.get(txId);
+        if (!tx)
+            throw new Error(`Transaction ${txId} not found`);
+        if (tx.status !== "pending")
+            throw new Error(`Transaction ${txId} is ${tx.status}, not pending`);
+        // Submit payment to x402 facilitator
+        const res = await fetch(`${this.x402.facilitatorUrl}/payments`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                amount: tx.amount,
+                token: this.x402.token || "USDC",
+                chain: this.x402.chain || "base",
+                from: this.x402.walletAddress,
+                memo: `mnemopay:${tx.id}:${tx.reason}`,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`x402 settlement failed (${res.status}): ${body}`);
+        }
+        // On success, settle locally
+        return this.settle(txId);
+    }
     async disconnect() {
-        this.log("Disconnected (in-memory mode, data discarded)");
+        this._saveToDisk();
+        if (this.persistTimer)
+            clearInterval(this.persistTimer);
+        this.log("Disconnected" + (this.persistPath ? " (data saved to disk)" : " (in-memory mode, data discarded)"));
     }
 }
 exports.MnemoPayLite = MnemoPayLite;
@@ -537,6 +815,82 @@ class MnemoPay extends EventEmitter {
             completedAt: t.completedAt ? new Date(t.completedAt) : undefined,
         }));
     }
+    // ── Reputation ──────────────────────────────────────────────────────────
+    async reputation() {
+        const [prof, txs] = await Promise.all([
+            this.profile(),
+            this.history(1000),
+        ]);
+        const settled = txs.filter((t) => t.status === "completed");
+        const refunded = txs.filter((t) => t.status === "refunded");
+        const totalCompleted = settled.length + refunded.length;
+        const settlementRate = totalCompleted > 0 ? settled.length / totalCompleted : 0;
+        const totalValueSettled = settled.reduce((sum, t) => sum + t.amount, 0);
+        return {
+            agentId: this.agentId,
+            score: prof.reputation,
+            tier: reputationTier(prof.reputation),
+            settledCount: settled.length,
+            refundCount: refunded.length,
+            settlementRate,
+            totalValueSettled,
+            memoriesCount: prof.memoriesCount,
+            avgMemoryImportance: 0, // not available via API
+            ageHours: 0, // not tracked server-side yet
+            generatedAt: new Date(),
+        };
+    }
+    // ── A2A Agent Card ─────────────────────────────────────────────────────
+    agentCard(url, contact) {
+        return {
+            name: `MnemoPay Agent (${this.agentId})`,
+            description: "AI agent with persistent cognitive memory and micropayment capabilities via MnemoPay protocol.",
+            url,
+            version: "0.2.0",
+            capabilities: {
+                memory: true,
+                payments: true,
+                reputation: true,
+            },
+            protocols: ["mcp", "a2a"],
+            tools: [
+                "remember", "recall", "forget", "reinforce", "consolidate",
+                "charge", "settle", "refund", "balance", "profile",
+                "reputation", "logs", "history",
+            ],
+            contact,
+        };
+    }
+    // ── x402 Settlement ────────────────────────────────────────────────────
+    x402;
+    configureX402(config) {
+        this.x402 = config;
+        this.log(`x402 configured: ${config.facilitatorUrl} (${config.token || "USDC"} on ${config.chain || "base"})`);
+    }
+    async settleViaX402(txId) {
+        if (!this.x402)
+            throw new Error("x402 not configured. Call configureX402() first.");
+        // Get transaction details from AgentPay
+        const txData = await this.agentpayFetch(`/api/escrow/${txId}`);
+        // Submit to x402 facilitator
+        const res = await fetch(`${this.x402.facilitatorUrl}/payments`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                amount: txData.amount,
+                token: this.x402.token || "USDC",
+                chain: this.x402.chain || "base",
+                from: this.x402.walletAddress,
+                memo: `mnemopay:${txId}:${txData.reason || ""}`,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`x402 settlement failed (${res.status}): ${body}`);
+        }
+        // On success, settle in AgentPay
+        return this.settle(txId);
+    }
     async disconnect() {
         this.log("Disconnected");
     }
@@ -555,7 +909,7 @@ class MnemoPay extends EventEmitter {
                 vectorWeight: opts.vectorWeight,
             }
             : undefined;
-        return new MnemoPayLite(agentId, opts?.decay ?? 0.05, opts?.debug ?? false, recallConfig);
+        return new MnemoPayLite(agentId, opts?.decay ?? 0.05, opts?.debug ?? false, recallConfig, opts?.fraud);
     }
     /**
      * Production mode. Connects to Mnemosyne + AgentPay backends.
@@ -573,4 +927,13 @@ Object.defineProperty(exports, "RecallEngine", { enumerable: true, get: function
 Object.defineProperty(exports, "cosineSimilarity", { enumerable: true, get: function () { return engine_js_2.cosineSimilarity; } });
 Object.defineProperty(exports, "localEmbed", { enumerable: true, get: function () { return engine_js_2.localEmbed; } });
 Object.defineProperty(exports, "l2Normalize", { enumerable: true, get: function () { return engine_js_2.l2Normalize; } });
+var fraud_js_2 = require("./fraud.js");
+Object.defineProperty(exports, "FraudGuard", { enumerable: true, get: function () { return fraud_js_2.FraudGuard; } });
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return fraud_js_2.RateLimiter; } });
+Object.defineProperty(exports, "DEFAULT_FRAUD_CONFIG", { enumerable: true, get: function () { return fraud_js_2.DEFAULT_FRAUD_CONFIG; } });
+Object.defineProperty(exports, "DEFAULT_RATE_LIMIT", { enumerable: true, get: function () { return fraud_js_2.DEFAULT_RATE_LIMIT; } });
+var fraud_ml_js_1 = require("./fraud-ml.js");
+Object.defineProperty(exports, "IsolationForest", { enumerable: true, get: function () { return fraud_ml_js_1.IsolationForest; } });
+Object.defineProperty(exports, "TransactionGraph", { enumerable: true, get: function () { return fraud_ml_js_1.TransactionGraph; } });
+Object.defineProperty(exports, "BehaviorProfile", { enumerable: true, get: function () { return fraud_ml_js_1.BehaviorProfile; } });
 //# sourceMappingURL=index.js.map