@webhook-platform/node 1.0.0

package/README.md

@@ -0,0 +1,252 @@
+# @webhook-platform/node
+
+Official Node.js SDK for [Webhook Platform](https://github.com/vadymkykalo/webhook-platform).
+
+## Installation
+
+```bash
+npm install @webhook-platform/node
+```
+
+## Quick Start
+
+```typescript
+import { WebhookPlatform } from '@webhook-platform/node';
+
+const client = new WebhookPlatform({
+  apiKey: 'wh_live_your_api_key',
+  baseUrl: 'http://localhost:8080', // optional, defaults to localhost
+});
+
+// Send an event
+const event = await client.events.send({
+  type: 'order.completed',
+  data: {
+    orderId: 'ord_12345',
+    amount: 99.99,
+    currency: 'USD',
+  },
+});
+
+console.log(`Event created: ${event.eventId}`);
+console.log(`Deliveries created: ${event.deliveriesCreated}`);
+```
+
+## API Reference
+
+### Events
+
+```typescript
+// Send event with idempotency key
+const event = await client.events.send(
+  { type: 'order.completed', data: { orderId: '123' } },
+  'unique-idempotency-key'
+);
+```
+
+### Endpoints
+
+```typescript
+// Create endpoint
+const endpoint = await client.endpoints.create(projectId, {
+  url: 'https://api.example.com/webhooks',
+  description: 'Production webhooks',
+  enabled: true,
+});
+
+// List endpoints
+const endpoints = await client.endpoints.list(projectId);
+
+// Update endpoint
+await client.endpoints.update(projectId, endpointId, {
+  enabled: false,
+});
+
+// Delete endpoint
+await client.endpoints.delete(projectId, endpointId);
+
+// Rotate secret
+const updated = await client.endpoints.rotateSecret(projectId, endpointId);
+console.log(`New secret: ${updated.secret}`);
+
+// Test endpoint connectivity
+const result = await client.endpoints.test(projectId, endpointId);
+console.log(`Test ${result.success ? 'passed' : 'failed'}: ${result.latencyMs}ms`);
+```
+
+### Subscriptions
+
+```typescript
+// Subscribe endpoint to event types
+const subscription = await client.subscriptions.create(projectId, {
+  endpointId: endpoint.id,
+  eventTypes: ['order.completed', 'order.cancelled'],
+  enabled: true,
+});
+
+// List subscriptions
+const subscriptions = await client.subscriptions.list(projectId);
+
+// Update subscription
+await client.subscriptions.update(projectId, subscriptionId, {
+  eventTypes: ['order.*'],
+});
+
+// Delete subscription
+await client.subscriptions.delete(projectId, subscriptionId);
+```
+
+### Deliveries
+
+```typescript
+// List deliveries with filters
+const deliveries = await client.deliveries.list(projectId, {
+  status: 'FAILED',
+  page: 0,
+  size: 20,
+});
+
+console.log(`Total failed: ${deliveries.totalElements}`);
+
+// Get delivery attempts
+const attempts = await client.deliveries.getAttempts(deliveryId);
+for (const attempt of attempts) {
+  console.log(`Attempt ${attempt.attemptNumber}: ${attempt.httpStatus} (${attempt.latencyMs}ms)`);
+}
+
+// Replay failed delivery
+await client.deliveries.replay(deliveryId);
+```
+
+## Webhook Signature Verification
+
+Verify incoming webhooks in your endpoint:
+
+```typescript
+import { verifySignature, constructEvent } from '@webhook-platform/node';
+
+app.post('/webhooks', (req, res) => {
+  const payload = req.body; // raw body string
+  const signature = req.headers['x-signature'];
+  const secret = process.env.WEBHOOK_SECRET;
+
+  try {
+    // Option 1: Just verify
+    verifySignature(payload, signature, secret);
+
+    // Option 2: Verify and parse
+    const event = constructEvent(payload, req.headers, secret);
+    
+    console.log(`Received ${event.type}:`, event.data);
+    
+    // Handle the event
+    switch (event.type) {
+      case 'order.completed':
+        handleOrderCompleted(event.data);
+        break;
+    }
+
+    res.status(200).send('OK');
+  } catch (err) {
+    console.error('Webhook verification failed:', err.message);
+    res.status(400).send('Invalid signature');
+  }
+});
+```
+
+### Express.js Example
+
+```typescript
+import express from 'express';
+import { constructEvent } from '@webhook-platform/node';
+
+const app = express();
+
+// Important: Use raw body for signature verification
+app.post('/webhooks', express.raw({ type: 'application/json' }), (req, res) => {
+  const event = constructEvent(
+    req.body.toString(),
+    req.headers,
+    process.env.WEBHOOK_SECRET
+  );
+
+  // Process event...
+  res.sendStatus(200);
+});
+```
+
+## Error Handling
+
+```typescript
+import { 
+  WebhookPlatformError, 
+  RateLimitError, 
+  AuthenticationError,
+  ValidationError 
+} from '@webhook-platform/node';
+
+try {
+  await client.events.send({ type: 'test', data: {} });
+} catch (err) {
+  if (err instanceof RateLimitError) {
+    // Wait and retry
+    console.log(`Rate limited. Retry after ${err.retryAfter}ms`);
+    await sleep(err.retryAfter);
+  } else if (err instanceof AuthenticationError) {
+    console.error('Invalid API key');
+  } else if (err instanceof ValidationError) {
+    console.error('Validation failed:', err.fieldErrors);
+  } else if (err instanceof WebhookPlatformError) {
+    console.error(`Error ${err.status}: ${err.message}`);
+  }
+}
+```
+
+## Configuration
+
+```typescript
+const client = new WebhookPlatform({
+  apiKey: 'wh_live_xxx',      // Required: Your API key
+  baseUrl: 'https://api.example.com', // Optional: API base URL
+  timeout: 30000,              // Optional: Request timeout in ms (default: 30000)
+});
+```
+
+## TypeScript Support
+
+This SDK is written in TypeScript and includes full type definitions:
+
+```typescript
+import type { 
+  Event, 
+  EventResponse, 
+  Endpoint, 
+  Delivery,
+  DeliveryStatus 
+} from '@webhook-platform/node';
+```
+
+## Development
+
+### Running Tests
+
+**Local (requires Node.js 16+):**
+```bash
+npm install
+npm test
+```
+
+**Docker:**
+```bash
+docker run --rm -v $(pwd):/app -w /app node:20-alpine sh -c "npm install && npm test"
+```
+
+### Building
+
+```bash
+npm run build
+```
+
+## License
+
+MIT

package/dist/__tests__/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/client.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const errors_1 = require("../errors");
+describe('WebhookPlatform Client', () => {
+    describe('constructor', () => {
+        it('should create client with API key', () => {
+            const client = new client_1.WebhookPlatform({ apiKey: 'test_api_key' });
+            expect(client).toBeInstanceOf(client_1.WebhookPlatform);
+        });
+        it('should throw error without API key', () => {
+            expect(() => new client_1.WebhookPlatform({ apiKey: '' })).toThrow('API key is required');
+        });
+        it('should use default base URL', () => {
+            const client = new client_1.WebhookPlatform({ apiKey: 'test_api_key' });
+            expect(client).toBeDefined();
+        });
+        it('should accept custom base URL', () => {
+            const client = new client_1.WebhookPlatform({
+                apiKey: 'test_api_key',
+                baseUrl: 'https://api.example.com',
+            });
+            expect(client).toBeDefined();
+        });
+        it('should accept custom timeout', () => {
+            const client = new client_1.WebhookPlatform({
+                apiKey: 'test_api_key',
+                timeout: 60000,
+            });
+            expect(client).toBeDefined();
+        });
+        it('should initialize all API modules', () => {
+            const client = new client_1.WebhookPlatform({ apiKey: 'test_api_key' });
+            expect(client.events).toBeDefined();
+            expect(client.endpoints).toBeDefined();
+            expect(client.subscriptions).toBeDefined();
+            expect(client.deliveries).toBeDefined();
+        });
+    });
+});
+describe('Error Classes', () => {
+    describe('WebhookPlatformError', () => {
+        it('should have correct properties', () => {
+            const error = new errors_1.WebhookPlatformError('Test error', 500, 'test_code');
+            expect(error.message).toBe('Test error');
+            expect(error.status).toBe(500);
+            expect(error.code).toBe('test_code');
+            expect(error.name).toBe('WebhookPlatformError');
+        });
+    });
+    describe('AuthenticationError', () => {
+        it('should have correct defaults', () => {
+            const error = new errors_1.AuthenticationError();
+            expect(error.message).toBe('Invalid API key');
+            expect(error.status).toBe(401);
+            expect(error.code).toBe('authentication_error');
+            expect(error.name).toBe('AuthenticationError');
+        });
+        it('should accept custom message', () => {
+            const error = new errors_1.AuthenticationError('Custom auth error');
+            expect(error.message).toBe('Custom auth error');
+        });
+    });
+    describe('ValidationError', () => {
+        it('should have field errors', () => {
+            const fieldErrors = { email: 'Invalid email', url: 'Invalid URL' };
+            const error = new errors_1.ValidationError('Validation failed', fieldErrors);
+            expect(error.message).toBe('Validation failed');
+            expect(error.status).toBe(400);
+            expect(error.code).toBe('validation_error');
+            expect(error.fieldErrors).toEqual(fieldErrors);
+        });
+        it('should default to empty field errors', () => {
+            const error = new errors_1.ValidationError('Validation failed');
+            expect(error.fieldErrors).toEqual({});
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.test.js","sourceRoot":"","sources":["../../src/__tests__/client.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { WebhookPlatform } from '../client';\nimport { WebhookPlatformError, AuthenticationError, ValidationError } from '../errors';\n\ndescribe('WebhookPlatform Client', () => {\n  describe('constructor', () => {\n    it('should create client with API key', () => {\n      const client = new WebhookPlatform({ apiKey: 'test_api_key' });\n      expect(client).toBeInstanceOf(WebhookPlatform);\n    });\n\n    it('should throw error without API key', () => {\n      expect(() => new WebhookPlatform({ apiKey: '' })).toThrow('API key is required');\n    });\n\n    it('should use default base URL', () => {\n      const client = new WebhookPlatform({ apiKey: 'test_api_key' });\n      expect(client).toBeDefined();\n    });\n\n    it('should accept custom base URL', () => {\n      const client = new WebhookPlatform({\n        apiKey: 'test_api_key',\n        baseUrl: 'https://api.example.com',\n      });\n      expect(client).toBeDefined();\n    });\n\n    it('should accept custom timeout', () => {\n      const client = new WebhookPlatform({\n        apiKey: 'test_api_key',\n        timeout: 60000,\n      });\n      expect(client).toBeDefined();\n    });\n\n    it('should initialize all API modules', () => {\n      const client = new WebhookPlatform({ apiKey: 'test_api_key' });\n      expect(client.events).toBeDefined();\n      expect(client.endpoints).toBeDefined();\n      expect(client.subscriptions).toBeDefined();\n      expect(client.deliveries).toBeDefined();\n    });\n  });\n});\n\ndescribe('Error Classes', () => {\n  describe('WebhookPlatformError', () => {\n    it('should have correct properties', () => {\n      const error = new WebhookPlatformError('Test error', 500, 'test_code');\n      expect(error.message).toBe('Test error');\n      expect(error.status).toBe(500);\n      expect(error.code).toBe('test_code');\n      expect(error.name).toBe('WebhookPlatformError');\n    });\n  });\n\n  describe('AuthenticationError', () => {\n    it('should have correct defaults', () => {\n      const error = new AuthenticationError();\n      expect(error.message).toBe('Invalid API key');\n      expect(error.status).toBe(401);\n      expect(error.code).toBe('authentication_error');\n      expect(error.name).toBe('AuthenticationError');\n    });\n\n    it('should accept custom message', () => {\n      const error = new AuthenticationError('Custom auth error');\n      expect(error.message).toBe('Custom auth error');\n    });\n  });\n\n  describe('ValidationError', () => {\n    it('should have field errors', () => {\n      const fieldErrors = { email: 'Invalid email', url: 'Invalid URL' };\n      const error = new ValidationError('Validation failed', fieldErrors);\n      expect(error.message).toBe('Validation failed');\n      expect(error.status).toBe(400);\n      expect(error.code).toBe('validation_error');\n      expect(error.fieldErrors).toEqual(fieldErrors);\n    });\n\n    it('should default to empty field errors', () => {\n      const error = new ValidationError('Validation failed');\n      expect(error.fieldErrors).toEqual({});\n    });\n  });\n});\n"]}

package/dist/__tests__/webhooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/webhooks.test.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const webhooks_1 = require("../webhooks");
+const errors_1 = require("../errors");
+describe('Webhook Signature Verification', () => {
+    const secret = 'whsec_test_secret_key_123';
+    const payload = JSON.stringify({ type: 'order.completed', data: { orderId: '12345' } });
+    describe('generateSignature', () => {
+        it('should generate valid signature format', () => {
+            const signature = (0, webhooks_1.generateSignature)(payload, secret);
+            expect(signature).toMatch(/^t=\d+,v1=[a-f0-9]{64}$/);
+        });
+        it('should use provided timestamp', () => {
+            const timestamp = 1700000000000;
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            expect(signature).toContain(`t=${timestamp}`);
+        });
+        it('should generate consistent signatures for same inputs', () => {
+            const timestamp = 1700000000000;
+            const sig1 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const sig2 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            expect(sig1).toBe(sig2);
+        });
+        it('should generate different signatures for different payloads', () => {
+            const timestamp = 1700000000000;
+            const sig1 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const sig2 = (0, webhooks_1.generateSignature)('different payload', secret, timestamp);
+            expect(sig1).not.toBe(sig2);
+        });
+        it('should generate different signatures for different secrets', () => {
+            const timestamp = 1700000000000;
+            const sig1 = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const sig2 = (0, webhooks_1.generateSignature)(payload, 'different_secret', timestamp);
+            expect(sig1).not.toBe(sig2);
+        });
+    });
+    describe('verifySignature', () => {
+        it('should verify valid signature', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            expect((0, webhooks_1.verifySignature)(payload, signature, secret)).toBe(true);
+        });
+        it('should throw on missing signature', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, '', secret)).toThrow(errors_1.WebhookPlatformError);
+            expect(() => (0, webhooks_1.verifySignature)(payload, '', secret)).toThrow('Missing signature header');
+        });
+        it('should throw on invalid signature format', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, 'invalid', secret)).toThrow('Invalid signature format');
+        });
+        it('should throw on missing timestamp', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, 'v1=abc123', secret)).toThrow('Invalid signature format');
+        });
+        it('should throw on missing v1 signature', () => {
+            expect(() => (0, webhooks_1.verifySignature)(payload, 't=1700000000000', secret)).toThrow('Invalid signature format');
+        });
+        it('should throw on expired timestamp', () => {
+            const oldTimestamp = Date.now() - 600000; // 10 minutes ago
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, oldTimestamp);
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret)).toThrow('outside tolerance window');
+        });
+        it('should throw on future timestamp outside tolerance', () => {
+            const futureTimestamp = Date.now() + 600000; // 10 minutes in future
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, futureTimestamp);
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret)).toThrow('outside tolerance window');
+        });
+        it('should accept timestamp within tolerance', () => {
+            const recentTimestamp = Date.now() - 60000; // 1 minute ago
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, recentTimestamp);
+            expect((0, webhooks_1.verifySignature)(payload, signature, secret)).toBe(true);
+        });
+        it('should throw on invalid signature value', () => {
+            const timestamp = Date.now();
+            const signature = `t=${timestamp},v1=invalid_signature_that_will_not_match`;
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret)).toThrow('Invalid signature');
+        });
+        it('should throw on tampered payload', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const tamperedPayload = JSON.stringify({ type: 'order.cancelled', data: {} });
+            expect(() => (0, webhooks_1.verifySignature)(tamperedPayload, signature, secret)).toThrow('Invalid signature');
+        });
+        it('should respect custom tolerance', () => {
+            const oldTimestamp = Date.now() - 60000; // 1 minute ago
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, oldTimestamp);
+            // Should fail with 30s tolerance
+            expect(() => (0, webhooks_1.verifySignature)(payload, signature, secret, { tolerance: 30000 }))
+                .toThrow('outside tolerance window');
+            // Should pass with 2min tolerance
+            expect((0, webhooks_1.verifySignature)(payload, signature, secret, { tolerance: 120000 })).toBe(true);
+        });
+    });
+    describe('constructEvent', () => {
+        it('should construct event from valid request', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+                'x-timestamp': timestamp.toString(),
+                'x-event-id': 'evt_123',
+                'x-delivery-id': 'dlv_456',
+            };
+            const event = (0, webhooks_1.constructEvent)(payload, headers, secret);
+            expect(event.eventId).toBe('evt_123');
+            expect(event.deliveryId).toBe('dlv_456');
+            expect(event.timestamp).toBe(timestamp);
+            expect(event.type).toBe('order.completed');
+            expect(event.data).toEqual({ orderId: '12345' });
+        });
+        it('should handle uppercase headers', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const headers = {
+                'X-Signature': signature,
+                'X-Timestamp': timestamp.toString(),
+                'X-Event-Id': 'evt_123',
+                'X-Delivery-Id': 'dlv_456',
+            };
+            const event = (0, webhooks_1.constructEvent)(payload, headers, secret);
+            expect(event.eventId).toBe('evt_123');
+        });
+        it('should throw on missing signature header', () => {
+            const headers = {
+                'x-timestamp': Date.now().toString(),
+            };
+            expect(() => (0, webhooks_1.constructEvent)(payload, headers, secret))
+                .toThrow('Missing X-Signature header');
+        });
+        it('should throw on invalid JSON payload', () => {
+            const timestamp = Date.now();
+            const invalidPayload = 'not valid json';
+            const signature = (0, webhooks_1.generateSignature)(invalidPayload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+                'x-timestamp': timestamp.toString(),
+            };
+            expect(() => (0, webhooks_1.constructEvent)(invalidPayload, headers, secret))
+                .toThrow('Invalid JSON payload');
+        });
+        it('should handle payload without nested data field', () => {
+            const flatPayload = JSON.stringify({ type: 'test.event', value: 123 });
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(flatPayload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+                'x-timestamp': timestamp.toString(),
+            };
+            const event = (0, webhooks_1.constructEvent)(flatPayload, headers, secret);
+            expect(event.type).toBe('test.event');
+            expect(event.data).toEqual({ type: 'test.event', value: 123 });
+        });
+        it('should use current timestamp if not provided in headers', () => {
+            const timestamp = Date.now();
+            const signature = (0, webhooks_1.generateSignature)(payload, secret, timestamp);
+            const headers = {
+                'x-signature': signature,
+            };
+            const event = (0, webhooks_1.constructEvent)(payload, headers, secret);
+            expect(event.timestamp).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhooks.test.js","sourceRoot":"","sources":["../../src/__tests__/webhooks.test.ts"],"names":[],"mappings":";;AAAA,0CAAiF;AACjF,sCAAiD;AAEjD,QAAQ,CAAC,gCAAgC,EAAE,GAAG,EAAE;IAC9C,MAAM,MAAM,GAAG,2BAA2B,CAAC;IAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;IAExF,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;QACjC,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;YAChD,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YACrD,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;YACvC,MAAM,SAAS,GAAG,aAAa,CAAC;YAChC,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAChE,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,KAAK,SAAS,EAAE,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,SAAS,GAAG,aAAa,CAAC;YAChC,MAAM,IAAI,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAC3D,MAAM,IAAI,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAC3D,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;YACrE,MAAM,SAAS,GAAG,aAAa,CAAC;YAChC,MAAM,IAAI,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAC3D,MAAM,IAAI,GAAG,IAAA,4BAAiB,EAAC,mBAAmB,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YACvE,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;YACpE,MAAM,SAAS,GAAG,aAAa,CAAC;YAChC,MAAM,IAAI,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAC3D,MAAM,IAAI,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,kBAAkB,EAAE,SAAS,CAAC,CAAC;YACvE,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;YACvC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAChE,MAAM,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,6BAAoB,CAAC,CAAC;YACjF,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QACzF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QAChG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QAClG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QACxG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,iBAAiB;YAC3D,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC;YACnE,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QAChG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,uBAAuB;YACpE,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC;YACtE,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC;QAChG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,eAAe;YAC3D,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC;YACtE,MAAM,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,GAAG,EAAE;YACjD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,KAAK,SAAS,2CAA2C,CAAC;YAC5E,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QACzF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;YAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAChE,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;YAC9E,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,eAAe,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QACjG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;YACzC,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,eAAe;YACxD,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC;YAEnE,iCAAiC;YACjC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;iBAC5E,OAAO,CAAC,0BAA0B,CAAC,CAAC;YAEvC,kCAAkC;YAClC,MAAM,CAAC,IAAA,0BAAe,EAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxF,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;QAC9B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;YACnD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAEhE,MAAM,OAAO,GAAG;gBACd,aAAa,EAAE,SAAS;gBACxB,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE;gBACnC,YAAY,EAAE,SAAS;gBACvB,eAAe,EAAE,SAAS;aAC3B,CAAC;YAEF,MAAM,KAAK,GAAG,IAAA,yBAAc,EAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAEvD,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACtC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACxC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAC3C,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;YACzC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAEhE,MAAM,OAAO,GAAG;gBACd,aAAa,EAAE,SAAS;gBACxB,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE;gBACnC,YAAY,EAAE,SAAS;gBACvB,eAAe,EAAE,SAAS;aAC3B,CAAC;YAEF,MAAM,KAAK,GAAG,IAAA,yBAAc,EAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YACvD,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,OAAO,GAAG;gBACd,aAAa,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;aACrC,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,yBAAc,EAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;iBACnD,OAAO,CAAC,4BAA4B,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,cAAc,GAAG,gBAAgB,CAAC;YACxC,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAEvE,MAAM,OAAO,GAAG;gBACd,aAAa,EAAE,SAAS;gBACxB,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE;aACpC,CAAC;YAEF,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,yBAAc,EAAC,cAAc,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;iBAC1D,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;YACvE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,WAAW,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAEpE,MAAM,OAAO,GAAG;gBACd,aAAa,EAAE,SAAS;gBACxB,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE;aACpC,CAAC;YAEF,MAAM,KAAK,GAAG,IAAA,yBAAc,EAAC,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAC3D,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACtC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;YACjE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAA,4BAAiB,EAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAEhE,MAAM,OAAO,GAAG;gBACd,aAAa,EAAE,SAAS;aACzB,CAAC;YAEF,MAAM,KAAK,GAAG,IAAA,yBAAc,EAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YACvD,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { verifySignature, constructEvent, generateSignature } from '../webhooks';\nimport { WebhookPlatformError } from '../errors';\n\ndescribe('Webhook Signature Verification', () => {\n  const secret = 'whsec_test_secret_key_123';\n  const payload = JSON.stringify({ type: 'order.completed', data: { orderId: '12345' } });\n\n  describe('generateSignature', () => {\n    it('should generate valid signature format', () => {\n      const signature = generateSignature(payload, secret);\n      expect(signature).toMatch(/^t=\\d+,v1=[a-f0-9]{64}$/);\n    });\n\n    it('should use provided timestamp', () => {\n      const timestamp = 1700000000000;\n      const signature = generateSignature(payload, secret, timestamp);\n      expect(signature).toContain(`t=${timestamp}`);\n    });\n\n    it('should generate consistent signatures for same inputs', () => {\n      const timestamp = 1700000000000;\n      const sig1 = generateSignature(payload, secret, timestamp);\n      const sig2 = generateSignature(payload, secret, timestamp);\n      expect(sig1).toBe(sig2);\n    });\n\n    it('should generate different signatures for different payloads', () => {\n      const timestamp = 1700000000000;\n      const sig1 = generateSignature(payload, secret, timestamp);\n      const sig2 = generateSignature('different payload', secret, timestamp);\n      expect(sig1).not.toBe(sig2);\n    });\n\n    it('should generate different signatures for different secrets', () => {\n      const timestamp = 1700000000000;\n      const sig1 = generateSignature(payload, secret, timestamp);\n      const sig2 = generateSignature(payload, 'different_secret', timestamp);\n      expect(sig1).not.toBe(sig2);\n    });\n  });\n\n  describe('verifySignature', () => {\n    it('should verify valid signature', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      expect(verifySignature(payload, signature, secret)).toBe(true);\n    });\n\n    it('should throw on missing signature', () => {\n      expect(() => verifySignature(payload, '', secret)).toThrow(WebhookPlatformError);\n      expect(() => verifySignature(payload, '', secret)).toThrow('Missing signature header');\n    });\n\n    it('should throw on invalid signature format', () => {\n      expect(() => verifySignature(payload, 'invalid', secret)).toThrow('Invalid signature format');\n    });\n\n    it('should throw on missing timestamp', () => {\n      expect(() => verifySignature(payload, 'v1=abc123', secret)).toThrow('Invalid signature format');\n    });\n\n    it('should throw on missing v1 signature', () => {\n      expect(() => verifySignature(payload, 't=1700000000000', secret)).toThrow('Invalid signature format');\n    });\n\n    it('should throw on expired timestamp', () => {\n      const oldTimestamp = Date.now() - 600000; // 10 minutes ago\n      const signature = generateSignature(payload, secret, oldTimestamp);\n      expect(() => verifySignature(payload, signature, secret)).toThrow('outside tolerance window');\n    });\n\n    it('should throw on future timestamp outside tolerance', () => {\n      const futureTimestamp = Date.now() + 600000; // 10 minutes in future\n      const signature = generateSignature(payload, secret, futureTimestamp);\n      expect(() => verifySignature(payload, signature, secret)).toThrow('outside tolerance window');\n    });\n\n    it('should accept timestamp within tolerance', () => {\n      const recentTimestamp = Date.now() - 60000; // 1 minute ago\n      const signature = generateSignature(payload, secret, recentTimestamp);\n      expect(verifySignature(payload, signature, secret)).toBe(true);\n    });\n\n    it('should throw on invalid signature value', () => {\n      const timestamp = Date.now();\n      const signature = `t=${timestamp},v1=invalid_signature_that_will_not_match`;\n      expect(() => verifySignature(payload, signature, secret)).toThrow('Invalid signature');\n    });\n\n    it('should throw on tampered payload', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      const tamperedPayload = JSON.stringify({ type: 'order.cancelled', data: {} });\n      expect(() => verifySignature(tamperedPayload, signature, secret)).toThrow('Invalid signature');\n    });\n\n    it('should respect custom tolerance', () => {\n      const oldTimestamp = Date.now() - 60000; // 1 minute ago\n      const signature = generateSignature(payload, secret, oldTimestamp);\n      \n      // Should fail with 30s tolerance\n      expect(() => verifySignature(payload, signature, secret, { tolerance: 30000 }))\n        .toThrow('outside tolerance window');\n      \n      // Should pass with 2min tolerance\n      expect(verifySignature(payload, signature, secret, { tolerance: 120000 })).toBe(true);\n    });\n  });\n\n  describe('constructEvent', () => {\n    it('should construct event from valid request', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n        'x-timestamp': timestamp.toString(),\n        'x-event-id': 'evt_123',\n        'x-delivery-id': 'dlv_456',\n      };\n\n      const event = constructEvent(payload, headers, secret);\n      \n      expect(event.eventId).toBe('evt_123');\n      expect(event.deliveryId).toBe('dlv_456');\n      expect(event.timestamp).toBe(timestamp);\n      expect(event.type).toBe('order.completed');\n      expect(event.data).toEqual({ orderId: '12345' });\n    });\n\n    it('should handle uppercase headers', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      \n      const headers = {\n        'X-Signature': signature,\n        'X-Timestamp': timestamp.toString(),\n        'X-Event-Id': 'evt_123',\n        'X-Delivery-Id': 'dlv_456',\n      };\n\n      const event = constructEvent(payload, headers, secret);\n      expect(event.eventId).toBe('evt_123');\n    });\n\n    it('should throw on missing signature header', () => {\n      const headers = {\n        'x-timestamp': Date.now().toString(),\n      };\n\n      expect(() => constructEvent(payload, headers, secret))\n        .toThrow('Missing X-Signature header');\n    });\n\n    it('should throw on invalid JSON payload', () => {\n      const timestamp = Date.now();\n      const invalidPayload = 'not valid json';\n      const signature = generateSignature(invalidPayload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n        'x-timestamp': timestamp.toString(),\n      };\n\n      expect(() => constructEvent(invalidPayload, headers, secret))\n        .toThrow('Invalid JSON payload');\n    });\n\n    it('should handle payload without nested data field', () => {\n      const flatPayload = JSON.stringify({ type: 'test.event', value: 123 });\n      const timestamp = Date.now();\n      const signature = generateSignature(flatPayload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n        'x-timestamp': timestamp.toString(),\n      };\n\n      const event = constructEvent(flatPayload, headers, secret);\n      expect(event.type).toBe('test.event');\n      expect(event.data).toEqual({ type: 'test.event', value: 123 });\n    });\n\n    it('should use current timestamp if not provided in headers', () => {\n      const timestamp = Date.now();\n      const signature = generateSignature(payload, secret, timestamp);\n      \n      const headers = {\n        'x-signature': signature,\n      };\n\n      const event = constructEvent(payload, headers, secret);\n      expect(event.timestamp).toBeGreaterThan(0);\n    });\n  });\n});\n"]}

package/dist/client.d.ts

@@ -0,0 +1,48 @@
+import { WebhookPlatformConfig, Event, EventResponse, Endpoint, EndpointCreateParams, EndpointUpdateParams, Subscription, SubscriptionCreateParams, Delivery, DeliveryAttempt, DeliveryListParams, PaginatedResponse, EndpointTestResult } from './types';
+export declare class WebhookPlatform {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    readonly events: Events;
+    readonly endpoints: Endpoints;
+    readonly subscriptions: Subscriptions;
+    readonly deliveries: Deliveries;
+    constructor(config: WebhookPlatformConfig);
+    request<T>(method: string, path: string, body?: unknown, idempotencyKey?: string): Promise<T>;
+    private extractRateLimitInfo;
+    private handleError;
+}
+declare class Events {
+    private client;
+    constructor(client: WebhookPlatform);
+    send(event: Event, idempotencyKey?: string): Promise<EventResponse>;
+}
+declare class Endpoints {
+    private client;
+    constructor(client: WebhookPlatform);
+    create(projectId: string, params: EndpointCreateParams): Promise<Endpoint>;
+    get(projectId: string, endpointId: string): Promise<Endpoint>;
+    list(projectId: string): Promise<Endpoint[]>;
+    update(projectId: string, endpointId: string, params: EndpointUpdateParams): Promise<Endpoint>;
+    delete(projectId: string, endpointId: string): Promise<void>;
+    rotateSecret(projectId: string, endpointId: string): Promise<Endpoint>;
+    test(projectId: string, endpointId: string): Promise<EndpointTestResult>;
+}
+declare class Subscriptions {
+    private client;
+    constructor(client: WebhookPlatform);
+    create(projectId: string, params: SubscriptionCreateParams): Promise<Subscription>;
+    get(projectId: string, subscriptionId: string): Promise<Subscription>;
+    list(projectId: string): Promise<Subscription[]>;
+    update(projectId: string, subscriptionId: string, params: Partial<SubscriptionCreateParams>): Promise<Subscription>;
+    delete(projectId: string, subscriptionId: string): Promise<void>;
+}
+declare class Deliveries {
+    private client;
+    constructor(client: WebhookPlatform);
+    get(deliveryId: string): Promise<Delivery>;
+    list(projectId: string, params?: DeliveryListParams): Promise<PaginatedResponse<Delivery>>;
+    getAttempts(deliveryId: string): Promise<DeliveryAttempt[]>;
+    replay(deliveryId: string): Promise<void>;
+}
+export {};