paybridge 0.3.1 → 0.5.0

package/README.md

@@ -194,6 +194,9 @@ app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
 | **Stripe** | ✅ | ✅ | ✅ | ✅ | **Production** |
 | **Peach Payments** | ✅ | ⛔ | ✅ | ✅ | **Production** |
 | **Flutterwave** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Adyen** | ✅ | ⛔ | ✅ | ✅ | **Production** |
+| **Mercado Pago** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Razorpay** | ✅ | ✅ | ✅ | ✅ | **Production** |
 
 ### Crypto on/off-ramp providers
 
@@ -207,7 +210,7 @@ app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
 **Notes:**
 - `⛔` marks features the underlying provider's API doesn't support — those methods throw a clear error explaining the limitation. Use a different provider for that capability or use `PayBridgeRouter` to route accordingly.
 - **Yellow Card** is gated behind `@experimental` until partner API documentation is verified — it logs a warning on instantiation. Do not use in production without partner-confirmed spec.
-- **Sandbox testing.** PayFast / PayStack / Stripe / Peach / Flutterwave are wired and unit-tested, but have not yet been validated against live sandbox credentials. To validate against real sandboxes, set the relevant `*_API_KEY` env vars and run `npm run test:e2e:sandbox`.
+- **Sandbox testing.** PayFast / PayStack / Stripe / Peach / Flutterwave / Adyen / Mercado Pago / Razorpay are wired and unit-tested, but have not yet been validated against live sandbox credentials. To validate against real sandboxes, set the relevant `*_API_KEY` env vars and run `npm run test:e2e:sandbox`.
 
 ## Provider Configuration
 
@@ -258,6 +261,58 @@ const pay = new PayBridge({
 
 **Docs:** [Ozow Hub](https://hub.ozow.com)
 
+### Adyen
+
+```typescript
+const pay = new PayBridge({
+  provider: 'adyen',
+  credentials: {
+    apiKey: 'your_api_key',
+    merchantAccount: 'YourMerchantAccount',
+    liveUrlPrefix: 'abc123' // Only for live mode
+  },
+  sandbox: true,
+  webhookSecret: 'your_hmac_key_hex'
+});
+```
+
+**Docs:** [Adyen API Explorer](https://docs.adyen.com/api-explorer/)
+
+**Note:** Adyen subscriptions require recurring tokenization flow (not yet supported). Use Stripe or PayFast for subscriptions.
+
+### Mercado Pago
+
+```typescript
+const pay = new PayBridge({
+  provider: 'mercadopago',
+  credentials: {
+    apiKey: 'TEST-...' // Or APP_USR-... for live
+  },
+  sandbox: true,
+  webhookSecret: 'your_webhook_secret'
+});
+```
+
+**Docs:** [Mercado Pago Developers](https://www.mercadopago.com/developers/en/reference)
+
+### Razorpay
+
+```typescript
+const pay = new PayBridge({
+  provider: 'razorpay',
+  credentials: {
+    apiKey: 'rzp_test_...', // key_id
+    secretKey: 'your_key_secret'
+  },
+  sandbox: true,
+  webhookSecret: 'your_webhook_secret'
+});
+```
+
+**Docs:** [Razorpay API Reference](https://razorpay.com/docs/api)
+
+**Note:** Razorpay webhooks do not include timestamp-based replay protection.
+
 ## Switch Providers in 1 Line
 
 ```typescript

package/dist/circuit-breaker.d.ts

@@ -3,6 +3,7 @@
  * Supports pluggable storage for multi-instance deployments.
  * Not atomic across processes — eventual consistency accepted.
  */
+import { EventEmitter } from 'node:events';
 import { CircuitBreakerStore } from './circuit-breaker-store';
 export declare enum CircuitState {
     CLOSED = "CLOSED",
@@ -15,6 +16,7 @@ export interface CircuitBreakerConfig {
     store?: CircuitBreakerStore;
 }
 export declare class CircuitBreaker {
+    readonly events: EventEmitter<any>;
     private readonly key;
     private readonly failureThreshold;
     private readonly resetTimeoutMs;

package/dist/circuit-breaker.js

@@ -6,6 +6,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CircuitBreaker = exports.CircuitState = void 0;
+const node_events_1 = require("node:events");
 const circuit_breaker_store_1 = require("./circuit-breaker-store");
 var CircuitState;
 (function (CircuitState) {
@@ -15,6 +16,7 @@ var CircuitState;
 })(CircuitState || (exports.CircuitState = CircuitState = {}));
 class CircuitBreaker {
     constructor(key = 'default', config = {}) {
+        this.events = new node_events_1.EventEmitter();
         this.key = key;
         this.failureThreshold = config.failureThreshold ?? 5;
         this.resetTimeoutMs = config.resetTimeoutMs ?? 30000;
@@ -26,6 +28,7 @@ class CircuitBreaker {
             if (Date.now() >= snapshot.nextAttemptTime) {
                 snapshot.state = CircuitState.HALF_OPEN;
                 await this.saveSnapshot(snapshot);
+                this.events.emit('half_opened', this.key);
                 return false;
             }
             return true;
@@ -33,12 +36,16 @@ class CircuitBreaker {
         return false;
     }
     async recordSuccess() {
+        const prevSnapshot = await this.getSnapshot();
         const snapshot = {
             state: CircuitState.CLOSED,
             failureCount: 0,
             nextAttemptTime: 0,
         };
         await this.saveSnapshot(snapshot);
+        if (prevSnapshot.state !== CircuitState.CLOSED) {
+            this.events.emit('closed', this.key);
+        }
     }
     async recordFailure() {
         const snapshot = await this.getSnapshot();
@@ -47,11 +54,13 @@ class CircuitBreaker {
             snapshot.state = CircuitState.OPEN;
             snapshot.nextAttemptTime = Date.now() + this.resetTimeoutMs;
             await this.saveSnapshot(snapshot, this.resetTimeoutMs + 5000);
+            this.events.emit('opened', this.key);
         }
         else if (snapshot.failureCount >= this.failureThreshold) {
             snapshot.state = CircuitState.OPEN;
             snapshot.nextAttemptTime = Date.now() + this.resetTimeoutMs;
             await this.saveSnapshot(snapshot, this.resetTimeoutMs + 5000);
+            this.events.emit('opened', this.key);
         }
         else {
             await this.saveSnapshot(snapshot);

package/dist/crypto/router.d.ts

@@ -3,6 +3,9 @@
  */
 import { CryptoRamp } from './index';
 import { OnRampParams, OffRampParams, RampQuote, RampResult } from './types';
+import { RouterEventEmitter } from '../router-events';
+import type { LedgerStore } from '../ledger';
+import type { TracerLike } from '../tracer';
 export interface CryptoRampRouterConfig {
     providers: Array<{
         provider: CryptoRamp;
@@ -17,13 +20,18 @@ export interface CryptoRampRouterConfig {
     allowExperimental?: boolean;
     circuitBreakerStore?: import('../circuit-breaker-store').CircuitBreakerStore;
     idempotencyStore?: import('../webhook-idempotency-store').IdempotencyStore;
+    ledger?: LedgerStore;
+    tracer?: TracerLike;
 }
 export declare class CryptoRampRouter {
+    readonly events: RouterEventEmitter;
     private providers;
     private strategy;
     private fallback;
     private allowExperimental;
     private circuitBreakers;
+    private ledger?;
+    private tracer;
     private rrIndex;
     private config;
     constructor(config: CryptoRampRouterConfig);
@@ -34,4 +42,5 @@ export declare class CryptoRampRouter {
     private filterProviders;
     private orderProviders;
     private sleep;
+    private recordLedgerEntry;
 }

package/dist/crypto/router.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoRampRouter = void 0;
 const routing_types_1 = require("../routing-types");
 const circuit_breaker_1 = require("../circuit-breaker");
+const router_events_1 = require("../router-events");
+const tracer_1 = require("../tracer");
 function sanitizeErrorMessage(msg) {
     if (!msg)
         return 'unknown error';
@@ -16,6 +18,7 @@ function sanitizeErrorMessage(msg) {
 }
 class CryptoRampRouter {
     constructor(config) {
+        this.events = new router_events_1.RouterEventEmitter();
         this.rrIndex = 0;
         this.config = config;
         this.providers = config.providers.map(p => ({
@@ -29,12 +32,36 @@ class CryptoRampRouter {
             retryDelayMs: config.fallback?.retryDelayMs ?? 250,
         };
         this.allowExperimental = config.allowExperimental ?? false;
+        this.ledger = config.ledger;
+        this.tracer = config.tracer ?? tracer_1.noopTracer;
         this.circuitBreakers = new Map();
         for (const p of this.providers) {
             const name = p.instance.getProviderName();
-            this.circuitBreakers.set(name, new circuit_breaker_1.CircuitBreaker(name, {
+            const breaker = new circuit_breaker_1.CircuitBreaker(name, {
                 store: config.circuitBreakerStore,
-            }));
+            });
+            breaker.events.on('opened', (key) => {
+                this.events.emitEvent({
+                    type: 'circuit.opened',
+                    provider: key,
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            breaker.events.on('half_opened', (key) => {
+                this.events.emitEvent({
+                    type: 'circuit.half_opened',
+                    provider: key,
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            breaker.events.on('closed', (key) => {
+                this.events.emitEvent({
+                    type: 'circuit.closed',
+                    provider: key,
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            this.circuitBreakers.set(name, breaker);
         }
     }
     async getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, network) {
@@ -114,6 +141,13 @@ class CryptoRampRouter {
                 continue;
             }
             const startTime = Date.now();
+            this.events.emitEvent({
+                type: 'attempt.start',
+                provider: providerName,
+                operation: 'createOnRamp',
+                attempt: attempts.length + 1,
+                timestamp: new Date().toISOString(),
+            });
             try {
                 const result = await providerMeta.instance.createOnRamp(params);
                 const latencyMs = Date.now() - startTime;
@@ -124,6 +158,32 @@ class CryptoRampRouter {
                     status: 'success',
                     latencyMs,
                 });
+                this.events.emitEvent({
+                    type: 'attempt.success',
+                    provider: providerName,
+                    operation: 'createOnRamp',
+                    durationMs: latencyMs,
+                    attempt: attempts.length,
+                    timestamp: new Date().toISOString(),
+                });
+                this.events.emitEvent({
+                    type: 'request.success',
+                    provider: providerName,
+                    operation: 'createOnRamp',
+                    durationMs: latencyMs,
+                    timestamp: new Date().toISOString(),
+                });
+                await this.recordLedgerEntry({
+                    id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    timestamp: new Date().toISOString(),
+                    operation: 'createOnRamp',
+                    provider: providerName,
+                    providerId: result.id,
+                    status: 'success',
+                    amount: params.fiatAmount,
+                    currency: params.fiatCurrency,
+                    durationMs: latencyMs,
+                });
                 const routingMeta = {
                     attempts,
                     chosenProvider: providerName,
@@ -146,12 +206,28 @@ class CryptoRampRouter {
                     errorMessage: sanitizeErrorMessage(error.message),
                     latencyMs,
                 });
+                this.events.emitEvent({
+                    type: 'attempt.failure',
+                    provider: providerName,
+                    operation: 'createOnRamp',
+                    durationMs: latencyMs,
+                    errorCode: error.code,
+                    errorMessage: sanitizeErrorMessage(error.message),
+                    attempt: attempts.length,
+                    timestamp: new Date().toISOString(),
+                });
                 if (!this.fallback.enabled || attempts.length >= this.fallback.maxAttempts) {
                     break;
                 }
                 await this.sleep(this.fallback.retryDelayMs);
             }
         }
+        this.events.emitEvent({
+            type: 'request.failure',
+            operation: 'createOnRamp',
+            errorMessage: lastError?.message || 'All providers failed',
+            timestamp: new Date().toISOString(),
+        });
         throw new routing_types_1.RoutingError(`All providers failed: ${lastError?.message || 'Unknown error'}`, attempts);
     }
     async createOffRamp(params) {
@@ -178,6 +254,13 @@ class CryptoRampRouter {
                 continue;
             }
             const startTime = Date.now();
+            this.events.emitEvent({
+                type: 'attempt.start',
+                provider: providerName,
+                operation: 'createOffRamp',
+                attempt: attempts.length + 1,
+                timestamp: new Date().toISOString(),
+            });
             try {
                 const result = await providerMeta.instance.createOffRamp(params);
                 const latencyMs = Date.now() - startTime;
@@ -188,6 +271,32 @@ class CryptoRampRouter {
                     status: 'success',
                     latencyMs,
                 });
+                this.events.emitEvent({
+                    type: 'attempt.success',
+                    provider: providerName,
+                    operation: 'createOffRamp',
+                    durationMs: latencyMs,
+                    attempt: attempts.length,
+                    timestamp: new Date().toISOString(),
+                });
+                this.events.emitEvent({
+                    type: 'request.success',
+                    provider: providerName,
+                    operation: 'createOffRamp',
+                    durationMs: latencyMs,
+                    timestamp: new Date().toISOString(),
+                });
+                await this.recordLedgerEntry({
+                    id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    timestamp: new Date().toISOString(),
+                    operation: 'createOffRamp',
+                    provider: providerName,
+                    providerId: result.id,
+                    status: 'success',
+                    amount: params.cryptoAmount,
+                    currency: params.fiatCurrency,
+                    durationMs: latencyMs,
+                });
                 const routingMeta = {
                     attempts,
                     chosenProvider: providerName,
@@ -210,12 +319,28 @@ class CryptoRampRouter {
                     errorMessage: sanitizeErrorMessage(error.message),
                     latencyMs,
                 });
+                this.events.emitEvent({
+                    type: 'attempt.failure',
+                    provider: providerName,
+                    operation: 'createOffRamp',
+                    durationMs: latencyMs,
+                    errorCode: error.code,
+                    errorMessage: sanitizeErrorMessage(error.message),
+                    attempt: attempts.length,
+                    timestamp: new Date().toISOString(),
+                });
                 if (!this.fallback.enabled || attempts.length >= this.fallback.maxAttempts) {
                     break;
                 }
                 await this.sleep(this.fallback.retryDelayMs);
             }
         }
+        this.events.emitEvent({
+            type: 'request.failure',
+            operation: 'createOffRamp',
+            errorMessage: lastError?.message || 'All providers failed',
+            timestamp: new Date().toISOString(),
+        });
         throw new routing_types_1.RoutingError(`All providers failed: ${lastError?.message || 'Unknown error'}`, attempts);
     }
     async getRamp(id, provider) {
@@ -291,5 +416,21 @@ class CryptoRampRouter {
     sleep(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
+    async recordLedgerEntry(entry) {
+        if (!this.ledger)
+            return;
+        try {
+            await this.ledger.append(entry);
+        }
+        catch (err) {
+            this.events.emitEvent({
+                type: 'attempt.failure',
+                operation: entry.operation,
+                provider: entry.provider,
+                errorMessage: 'Ledger write failed',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
 }
 exports.CryptoRampRouter = CryptoRampRouter;

package/dist/index.d.ts

@@ -16,8 +16,12 @@ export * from './strategies';
 export * from './router';
 export * from './crypto';
 export * from './webhook-idempotency-store';
+export * from './router-events';
+export * from './ledger';
+export * from './tracer';
 export { createRedisCircuitBreakerStore, type RedisLike, type RedisStoreOptions } from './stores/redis';
 export { createRedisIdempotencyStore, type RedisIdempotencyStoreOptions } from './stores/redis-idempotency';
+export { createRedisLedgerStore, type RedisLedgerStoreOptions } from './stores/redis-ledger';
 export declare class PayBridge {
     readonly provider: PaymentProvider;
     constructor(config: PayBridgeConfig);

package/dist/index.js

@@ -20,7 +20,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PayBridge = exports.createRedisIdempotencyStore = exports.createRedisCircuitBreakerStore = void 0;
+exports.PayBridge = exports.createRedisLedgerStore = exports.createRedisIdempotencyStore = exports.createRedisCircuitBreakerStore = void 0;
 const softycomp_1 = require("./providers/softycomp");
 const yoco_1 = require("./providers/yoco");
 const ozow_1 = require("./providers/ozow");
@@ -29,6 +29,9 @@ const stripe_1 = require("./providers/stripe");
 const payfast_1 = require("./providers/payfast");
 const paystack_1 = require("./providers/paystack");
 const flutterwave_1 = require("./providers/flutterwave");
+const adyen_1 = require("./providers/adyen");
+const mercadopago_1 = require("./providers/mercadopago");
+const razorpay_1 = require("./providers/razorpay");
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/currency"), exports);
 __exportStar(require("./utils/fetch"), exports);
@@ -39,10 +42,15 @@ __exportStar(require("./strategies"), exports);
 __exportStar(require("./router"), exports);
 __exportStar(require("./crypto"), exports);
 __exportStar(require("./webhook-idempotency-store"), exports);
+__exportStar(require("./router-events"), exports);
+__exportStar(require("./ledger"), exports);
+__exportStar(require("./tracer"), exports);
 var redis_1 = require("./stores/redis");
 Object.defineProperty(exports, "createRedisCircuitBreakerStore", { enumerable: true, get: function () { return redis_1.createRedisCircuitBreakerStore; } });
 var redis_idempotency_1 = require("./stores/redis-idempotency");
 Object.defineProperty(exports, "createRedisIdempotencyStore", { enumerable: true, get: function () { return redis_idempotency_1.createRedisIdempotencyStore; } });
+var redis_ledger_1 = require("./stores/redis-ledger");
+Object.defineProperty(exports, "createRedisLedgerStore", { enumerable: true, get: function () { return redis_ledger_1.createRedisLedgerStore; } });
 class PayBridge {
     constructor(config) {
         this.provider = this.createProvider(config);
@@ -130,6 +138,36 @@ class PayBridge {
                     sandbox,
                     webhookSecret,
                 });
+            case 'adyen':
+                if (!credentials.apiKey || !credentials.merchantAccount) {
+                    throw new Error('Adyen requires apiKey and merchantAccount');
+                }
+                return new adyen_1.AdyenProvider({
+                    apiKey: credentials.apiKey,
+                    merchantAccount: credentials.merchantAccount,
+                    liveUrlPrefix: credentials.liveUrlPrefix,
+                    sandbox,
+                    webhookSecret,
+                });
+            case 'mercadopago':
+                if (!credentials.apiKey) {
+                    throw new Error('Mercado Pago requires apiKey (access token TEST-* or APP_USR-*)');
+                }
+                return new mercadopago_1.MercadoPagoProvider({
+                    accessToken: credentials.apiKey,
+                    sandbox,
+                    webhookSecret,
+                });
+            case 'razorpay':
+                if (!credentials.apiKey || !credentials.secretKey) {
+                    throw new Error('Razorpay requires apiKey (key_id rzp_test_* or rzp_live_*) and secretKey (key_secret)');
+                }
+                return new razorpay_1.RazorpayProvider({
+                    keyId: credentials.apiKey,
+                    keySecret: credentials.secretKey,
+                    sandbox,
+                    webhookSecret,
+                });
             default:
                 throw new Error(`Unknown provider: ${provider}`);
         }

package/dist/ledger.d.ts

@@ -0,0 +1,36 @@
+export interface LedgerEntry {
+    id: string;
+    timestamp: string;
+    operation: 'createPayment' | 'createSubscription' | 'getPayment' | 'refund' | 'createOnRamp' | 'createOffRamp' | 'getRamp' | 'parseWebhook';
+    provider: string;
+    reference?: string;
+    providerId?: string;
+    status: 'attempted' | 'success' | 'failed' | 'rate_limited' | 'timeout';
+    amount?: number;
+    currency?: string;
+    durationMs?: number;
+    errorCode?: string;
+    errorMessage?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LedgerQuery {
+    reference?: string;
+    provider?: string;
+    status?: LedgerEntry['status'];
+    fromTimestamp?: string;
+    toTimestamp?: string;
+    limit?: number;
+}
+export interface LedgerStore {
+    append(entry: LedgerEntry): Promise<void>;
+    query(filter: LedgerQuery): Promise<LedgerEntry[]>;
+}
+export declare class InMemoryLedgerStore implements LedgerStore {
+    private entries;
+    private maxSize;
+    constructor(opts?: {
+        maxSize?: number;
+    });
+    append(entry: LedgerEntry): Promise<void>;
+    query(filter: LedgerQuery): Promise<LedgerEntry[]>;
+}

package/dist/ledger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLedgerStore = void 0;
+class InMemoryLedgerStore {
+    constructor(opts = {}) {
+        this.entries = [];
+        this.maxSize = opts.maxSize ?? 10000;
+    }
+    async append(entry) {
+        this.entries.push(entry);
+        if (this.entries.length > this.maxSize) {
+            this.entries.splice(0, this.entries.length - this.maxSize);
+        }
+    }
+    async query(filter) {
+        let results = this.entries;
+        if (filter.reference)
+            results = results.filter(e => e.reference === filter.reference);
+        if (filter.provider)
+            results = results.filter(e => e.provider === filter.provider);
+        if (filter.status)
+            results = results.filter(e => e.status === filter.status);
+        if (filter.fromTimestamp)
+            results = results.filter(e => e.timestamp >= filter.fromTimestamp);
+        if (filter.toTimestamp)
+            results = results.filter(e => e.timestamp <= filter.toTimestamp);
+        if (filter.limit)
+            results = results.slice(0, filter.limit);
+        return [...results];
+    }
+}
+exports.InMemoryLedgerStore = InMemoryLedgerStore;

package/dist/providers/adyen.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Adyen payment provider
+ * Global payment platform supporting 150+ countries
+ * @see https://docs.adyen.com/api-explorer/Checkout/71/overview
+ */
+import { PaymentProvider } from './base';
+import { CreatePaymentParams, PaymentResult, CreateSubscriptionParams, SubscriptionResult, RefundParams, RefundResult, WebhookEvent } from '../types';
+import { ProviderCapabilities } from '../routing-types';
+interface AdyenConfig {
+    apiKey: string;
+    merchantAccount: string;
+    liveUrlPrefix?: string;
+    webhookSecret?: string;
+    sandbox?: boolean;
+}
+export declare class AdyenProvider extends PaymentProvider {
+    readonly name = "adyen";
+    readonly supportedCurrencies: string[];
+    private apiKey;
+    private merchantAccount;
+    private liveUrlPrefix?;
+    private webhookSecret?;
+    private sandbox;
+    private baseUrl;
+    constructor(config: AdyenConfig);
+    private apiRequest;
+    createPayment(params: CreatePaymentParams): Promise<PaymentResult>;
+    /**
+     * Adyen subscriptions require recurring tokenization flow (shopperReference + recurring contract).
+     * This is not yet supported by paybridge's simple checkout URL model.
+     * Use Stripe or PayFast for subscriptions.
+     */
+    createSubscription(_params: CreateSubscriptionParams): Promise<SubscriptionResult>;
+    getPayment(id: string): Promise<PaymentResult>;
+    refund(params: RefundParams): Promise<RefundResult>;
+    /**
+     * Parse Adyen webhook notification.
+     * Note: Adyen webhooks contain multiple notificationItems in a batch.
+     * This method returns only the FIRST item (paybridge webhook interface is single-event).
+     * Multi-event batches require custom handling outside paybridge.
+     */
+    parseWebhook(body: any, _headers?: any): WebhookEvent;
+    verifyWebhook(body: string | Buffer, _headers?: any): boolean;
+    getCapabilities(): ProviderCapabilities;
+}
+export {};