@fedpulse/sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FedPulse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,331 @@
+# @fedpulse/sdk
+
+[![npm version](https://img.shields.io/npm/v/@fedpulse/sdk)](https://www.npmjs.com/package/@fedpulse/sdk)
+[![Node.js ≥18](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official JavaScript / TypeScript SDK for the [FedPulse API](https://fedpulse.dev). Search federal contract opportunities, check vendor exclusions, retrieve entity registrations, and access market intelligence — all with zero runtime dependencies.
+
+---
+
+## Features
+
+- **Typed end-to-end** — full TypeScript definitions for every request and response
+- **Dual ESM + CJS** — works in Node.js (ESM / CommonJS), Deno, Bun, and bundlers
+- **Zero runtime dependencies** — only uses Node.js built-ins (`fetch`, `crypto`)
+- **Automatic retry** — exponential back-off with full jitter for 5xx / network errors
+- **In-memory LRU cache** — 256-entry, 60 s TTL on all GET requests
+- **Webhook verification** — HMAC-SHA256 signature + replay-attack protection
+- **Cursor + offset pagination** — async generator helpers for all list endpoints
+
+---
+
+## Requirements
+
+- Node.js **≥ 18.0.0** (native `fetch` + `crypto`)
+- A FedPulse API key — generate one at [app.fedpulse.dev/dashboard](https://app.fedpulse.dev/dashboard)
+
+---
+
+## Installation
+
+```bash
+npm install @fedpulse/sdk
+```
+
+---
+
+## Quick start
+
+```ts
+import { FedPulse } from '@fedpulse/sdk';
+
+const client = new FedPulse({ apiKey: process.env.FEDPULSE_API_KEY! });
+
+// Search opportunities
+const result = await client.opportunities.list({
+  keyword: 'cybersecurity',
+  naics: ['541519', '541512'],
+  postedAfter: '2025-01-01',
+  limit: 25,
+});
+
+console.log(result.data);        // typed OpportunitySummary[]
+console.log(result.pagination);  // { total, page, limit, … }
+```
+
+---
+
+## Authentication
+
+Pass your API key to the constructor. It is sent as `Authorization: Bearer <key>` on every request.
+
+```ts
+const client = new FedPulse({ apiKey: 'fp_live_…' });
+```
+
+Never hard-code keys in source — use environment variables.
+
+---
+
+## Resources
+
+### `client.opportunities`
+
+```ts
+// List / search opportunities
+await client.opportunities.list({ keyword: 'cloud', naics: ['541512'] });
+
+// Retrieve a single opportunity
+await client.opportunities.get('abc123-notice-id');
+
+// Aggregate statistics
+await client.opportunities.stats({ postedAfter: '2025-01-01' });
+
+// Request a data export (async job)
+await client.opportunities.createExport({ format: 'csv', filter: { keyword: 'AI' } });
+
+// Async generator — walks all pages automatically
+for await (const page of client.opportunities.paginate({ keyword: 'defense' })) {
+  console.log(page.data);
+}
+```
+
+### `client.exclusions`
+
+```ts
+// List all current exclusions
+await client.exclusions.list({ active: true });
+
+// Retrieve one record
+await client.exclusions.get('exclusion-id');
+
+// Bulk check up to 100 entities
+await client.exclusions.check({
+  entities: [
+    { uei: 'ABC123DEF456' },
+    { cage: '1A2B3' },
+    { name: 'Acme Corp' },
+  ],
+});
+
+// Stats
+await client.exclusions.stats();
+
+// Page through all exclusions
+for await (const page of client.exclusions.paginate()) {
+  console.log(page.data);
+}
+```
+
+### `client.entities`
+
+```ts
+// List registered entities
+await client.entities.list({ naics: ['336411'], state: 'VA' });
+
+// Entity by UEI
+await client.entities.get('ABCDEF123456');
+
+// Contracts awarded to an entity
+await client.entities.opportunities('ABCDEF123456', { limit: 50 });
+
+// Exclusion check (never cached)
+await client.entities.exclusionCheck('ABCDEF123456');
+
+// Stats
+await client.entities.stats();
+
+// All pages
+for await (const page of client.entities.paginate({ state: 'TX' })) {
+  console.log(page.data);
+}
+```
+
+### `client.intelligence`
+
+```ts
+// 360° entity intelligence profile
+await client.intelligence.entityProfile('ABCDEF123456');
+
+// Market analysis for a NAICS code
+await client.intelligence.marketAnalysis('541512');
+
+// Bulk compliance check
+await client.intelligence.complianceCheck({
+  entities: [{ uei: 'ABCDEF123456' }, { name: 'Bad Actor LLC' }],
+});
+```
+
+### `client.assistance`
+
+Federal grants and assistance listings.
+
+```ts
+await client.assistance.list({ keyword: 'broadband', agency: 'USDA' });
+await client.assistance.get('listing-id');
+await client.assistance.getByProgram('10.001');
+await client.assistance.stats();
+for await (const page of client.assistance.paginate()) { … }
+```
+
+### `client.analytics`
+
+```ts
+await client.analytics.overview({ period: '30d' });
+await client.analytics.usageSummary();
+await client.analytics.topKeywords({ limit: 20 });
+```
+
+### `client.webhooks`
+
+```ts
+// List configured webhooks
+await client.webhooks.list();
+
+// Create
+await client.webhooks.create({ url: 'https://example.com/hook', events: ['opportunity.posted'] });
+
+// Update / delete
+await client.webhooks.update('wh_id', { active: false });
+await client.webhooks.delete('wh_id');
+
+// Deliveries log
+await client.webhooks.listDeliveries('wh_id');
+await client.webhooks.getDelivery('wh_id', 'delivery-id');
+await client.webhooks.redeliver('wh_id', 'delivery-id');
+```
+
+---
+
+## Webhook signature verification
+
+```ts
+import { FedPulse } from '@fedpulse/sdk';
+
+// In your Express / Fastify handler:
+app.post('/webhooks', (req, res) => {
+  const { signatureHeader, timestampHeader } = FedPulse.extractWebhookHeaders(req.headers);
+
+  let event;
+  try {
+    event = FedPulse.verifyWebhook({
+      rawBody: req.body,           // Buffer or string — the raw unparsed body
+      signatureHeader,
+      timestampHeader,
+      secret: process.env.FEDPULSE_WEBHOOK_SECRET!,
+      options: { maxAgeSeconds: 300 },
+    });
+  } catch (err) {
+    return res.status(400).send('Invalid signature');
+  }
+
+  console.log(event.event, event.data);
+  res.sendStatus(200);
+});
+```
+
+---
+
+## Pagination helpers
+
+Every list resource exposes a `paginate()` async generator that walks all pages for you:
+
+```ts
+const allOpps: OpportunitySummary[] = [];
+
+for await (const page of client.opportunities.paginate({ keyword: 'cloud' })) {
+  allOpps.push(...page.data);
+}
+```
+
+---
+
+## Error handling
+
+All errors extend `FedPulseError`. Import specific classes for precise handling:
+
+```ts
+import {
+  FedPulse,
+  AuthenticationError,
+  PermissionError,
+  NotFoundError,
+  ValidationError,
+  RateLimitError,
+  ServerError,
+  NetworkError,
+  TimeoutError,
+  RetryExhaustedError,
+} from '@fedpulse/sdk';
+
+try {
+  await client.opportunities.get('bad-id');
+} catch (err) {
+  if (err instanceof NotFoundError) {
+    console.log('Not found');
+  } else if (err instanceof RateLimitError) {
+    console.log(`Rate limited. Retry after: ${err.retryAfter}s`);
+  } else if (err instanceof RetryExhaustedError) {
+    console.log(`Failed after ${err.attempts} attempts`, err.lastError);
+  } else if (err instanceof NetworkError) {
+    console.log('Network issue — check internet connection');
+  }
+}
+```
+
+| Class | Status | When thrown |
+|---|---|---|
+| `AuthenticationError` | 401 | Invalid or missing API key |
+| `PermissionError` | 403 | Key lacks required permission |
+| `NotFoundError` | 404 | Resource does not exist |
+| `ValidationError` | 400/422 | Bad request parameters |
+| `RateLimitError` | 429 | Too many requests (check `retryAfter`) |
+| `ServerError` | 5xx | FedPulse server error |
+| `NetworkError` | — | DNS failure, ECONNREFUSED, etc. |
+| `TimeoutError` | — | Request exceeded `timeoutMs` |
+| `RetryExhaustedError` | — | All retry attempts failed |
+
+---
+
+## Configuration
+
+```ts
+const client = new FedPulse({
+  apiKey: 'fp_live_…',        // required
+  baseUrl: 'https://api.fedpulse.dev', // optional override
+  timeoutMs: 30_000,          // per-attempt timeout (default: 30 s)
+  maxRetries: 3,              // retries for 5xx / network errors (default: 3)
+  cacheSize: 256,             // LRU cache entries, 0 to disable (default: 256)
+  cacheTtlMs: 60_000,         // cache TTL in ms (default: 60 s)
+});
+```
+
+### Rate limit info
+
+```ts
+const { data } = await client.opportunities.list({ keyword: 'cloud' });
+console.log(client.rateLimit);
+// { limit: 1000, remaining: 987, reset: 1740000000 }
+```
+
+### Clear cache
+
+```ts
+client.clearCache();
+```
+
+---
+
+## CommonJS usage
+
+```js
+const { FedPulse } = require('@fedpulse/sdk');
+const client = new FedPulse({ apiKey: process.env.FEDPULSE_API_KEY });
+```
+
+---
+
+## License
+
+MIT © [FedPulse](https://fedpulse.dev)

package/dist/cjs/client.cjs

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * FedPulse SDK — main client class.
+ *
+ * Instantiate this class with your API key to access all FedPulse
+ * data resources and the webhook verification utility.
+ *
+ * @example
+ * ```ts
+ * import { FedPulse } from '@fedpulse/sdk';
+ *
+ * const client = new FedPulse({ apiKey: process.env.FEDPULSE_API_KEY! });
+ *
+ * // Search contracts
+ * const { data } = await client.opportunities.list({ q: 'cloud', naics: '541512' });
+ *
+ * // Compliance check
+ * const { data: status } = await client.exclusions.check({ entities: [{ uei: 'ABCDEF123456' }] });
+ *
+ * // Verify an incoming webhook
+ * const payload = FedPulse.verifyWebhook({ rawBody, signatureHeader, timestampHeader, secret });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookVerificationError = exports.FedPulse = void 0;
+const http_js_1 = require("./http.cjs");
+const opportunities_js_1 = require("./resources/opportunities.cjs");
+const exclusions_js_1 = require("./resources/exclusions.cjs");
+const entities_js_1 = require("./resources/entities.cjs");
+const intelligence_js_1 = require("./resources/intelligence.cjs");
+const assistance_js_1 = require("./resources/assistance.cjs");
+const analytics_js_1 = require("./resources/analytics.cjs");
+const webhooks_js_1 = require("./resources/webhooks.cjs");
+const webhooks_verify_js_1 = require("./webhooks-verify.cjs");
+Object.defineProperty(exports, "WebhookVerificationError", { enumerable: true, get: function () { return webhooks_verify_js_1.WebhookVerificationError; } });
+// ── Main client class ──────────────────────────────────────────────────────────
+/**
+ * The FedPulse SDK client.
+ *
+ * All API interactions go through the resource properties on this class.
+ * The static `verifyWebhook` method can be used independently of a client instance.
+ */
+class FedPulse {
+    /** Low-level HTTP client (exposed for advanced usage only). */
+    http;
+    /** Federal contract opportunities (/v1/opportunities). */
+    opportunities;
+    /** SAM.gov exclusions and bulk compliance checks (/v1/exclusions). */
+    exclusions;
+    /** SAM.gov registered entities / vendors (/v1/entities). */
+    entities;
+    /** 360° entity intelligence and market analysis (/v1/intelligence). */
+    intelligence;
+    /** Federal assistance listings / CFDA programs (/v1/assistance). */
+    assistance;
+    /** Per-user API usage analytics (/v1/analytics). */
+    analytics;
+    /** Webhook subscription management (/v1/webhooks). */
+    webhooks;
+    constructor(options) {
+        this.http = new http_js_1.HttpClient(options);
+        this.opportunities = new opportunities_js_1.OpportunitiesResource(this.http);
+        this.exclusions = new exclusions_js_1.ExclusionsResource(this.http);
+        this.entities = new entities_js_1.EntitiesResource(this.http);
+        this.intelligence = new intelligence_js_1.IntelligenceResource(this.http);
+        this.assistance = new assistance_js_1.AssistanceResource(this.http);
+        this.analytics = new analytics_js_1.AnalyticsResource(this.http);
+        this.webhooks = new webhooks_js_1.WebhooksResource(this.http);
+    }
+    /**
+     * Most recent rate-limit info observed from API responses.
+     *
+     * Updated after every API call. Useful for monitoring your rate-limit usage.
+     *
+     * @example
+     * ```ts
+     * await client.opportunities.list({ limit: 25 });
+     * console.log('Remaining requests:', client.rateLimit?.remaining);
+     * ```
+     */
+    get rateLimit() {
+        return this.http.lastRateLimit;
+    }
+    /**
+     * Clear the in-memory response cache.
+     *
+     * Useful after writes that may invalidate cached GET responses.
+     */
+    clearCache() {
+        this.http.clearCache();
+    }
+    // ── Static webhook utilities ───────────────────────────────────────────────
+    /**
+     * Verify an incoming FedPulse webhook delivery.
+     *
+     * Validates the HMAC-SHA256 signature, checks the timestamp against replay
+     * attacks, and returns the parsed payload on success.
+     *
+     * **IMPORTANT:** Pass the raw request body bytes — do not parse to JSON first.
+     *
+     * @param input  Headers, raw body, and signing secret.
+     * @returns Parsed, verified webhook payload.
+     * @throws {WebhookVerificationError} If signature/timestamp is invalid.
+     *
+     * @example
+     * ```ts
+     * // Express.js with `express.raw({ type: 'application/json' })`:
+     * const payload = FedPulse.verifyWebhook<{ noticeId: string }>({
+     *   rawBody: req.body,               // Buffer from express.raw()
+     *   signatureHeader: req.headers['x-fedpulse-signature'] as string,
+     *   timestampHeader: req.headers['x-fedpulse-timestamp'] as string,
+     *   secret: process.env.FEDPULSE_WEBHOOK_SECRET!,
+     * });
+     * console.log(payload.event, payload.data.noticeId);
+     * ```
+     */
+    static verifyWebhook(input) {
+        return (0, webhooks_verify_js_1.verifyWebhook)(input);
+    }
+    /**
+     * Extract FedPulse webhook headers from a request headers object.
+     *
+     * Handles case-insensitive lookup across Express, Fastify, Next.js, etc.
+     *
+     * @param headers  Headers object (plain object or `Headers` instance).
+     * @returns  Signature header, timestamp header, event type, and delivery ID.
+     *
+     * @example
+     * ```ts
+     * const { signatureHeader, timestampHeader } = FedPulse.extractWebhookHeaders(req.headers);
+     * const payload = FedPulse.verifyWebhook({ rawBody, signatureHeader, timestampHeader, secret });
+     * ```
+     */
+    static extractWebhookHeaders(headers) {
+        return (0, webhooks_verify_js_1.extractWebhookHeaders)(headers);
+    }
+}
+exports.FedPulse = FedPulse;

package/dist/cjs/errors.cjs

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * FedPulse SDK error classes.
+ *
+ * All errors thrown by the SDK extend FedPulseError so callers can use
+ * `instanceof FedPulseError` to distinguish SDK errors from other exceptions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryExhaustedError = exports.TimeoutError = exports.NetworkError = exports.ServerError = exports.RateLimitError = exports.ValidationError = exports.NotFoundError = exports.PermissionError = exports.AuthenticationError = exports.FedPulseError = void 0;
+exports.createApiError = createApiError;
+// ── Base error ─────────────────────────────────────────────────────────────────
+/**
+ * Base class for all FedPulse SDK errors.
+ */
+class FedPulseError extends Error {
+    /** HTTP status code returned by the API, or 0 for network errors. */
+    status;
+    /** Machine-readable error code from the API (e.g. NOT_FOUND, RATE_LIMIT_EXCEEDED). */
+    code;
+    /** Request ID for debugging — correlates with API logs. */
+    requestId;
+    /** Additional structured details from the API response. */
+    details;
+    constructor({ message, status, code, requestId, details, }) {
+        super(message);
+        this.name = 'FedPulseError';
+        this.status = status;
+        this.code = code;
+        this.requestId = requestId;
+        this.details = details;
+        // Restore prototype chain after `extends Error` in transpiled output.
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.FedPulseError = FedPulseError;
+// ── Specific error subtypes ────────────────────────────────────────────────────
+/**
+ * Thrown when the API returns 401 Unauthorized.
+ * Usually caused by missing, invalid, or revoked API key / JWT.
+ */
+class AuthenticationError extends FedPulseError {
+    constructor(params) {
+        super({ ...params, status: 401, code: 'UNAUTHORIZED' });
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/**
+ * Thrown when the API returns 403 Forbidden.
+ * Usually caused by insufficient plan permissions or missing key scope.
+ */
+class PermissionError extends FedPulseError {
+    constructor(params) {
+        super({ ...params, status: 403, code: params.code ?? 'FORBIDDEN' });
+        this.name = 'PermissionError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.PermissionError = PermissionError;
+/**
+ * Thrown when the API returns 404 Not Found.
+ */
+class NotFoundError extends FedPulseError {
+    constructor(params) {
+        super({ ...params, status: 404, code: 'NOT_FOUND' });
+        this.name = 'NotFoundError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Thrown when the API returns 422 Unprocessable Entity or 400 Bad Request
+ * due to invalid request parameters or body.
+ */
+class ValidationError extends FedPulseError {
+    constructor(params) {
+        super({ ...params, status: params.status ?? 422, code: 'VALIDATION_ERROR' });
+        this.name = 'ValidationError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Thrown when the API returns 429 Too Many Requests.
+ * The `retryAfter` property indicates when the rate limit resets (Unix seconds).
+ */
+class RateLimitError extends FedPulseError {
+    /** Unix epoch seconds when the rate limit window resets. */
+    retryAfter;
+    constructor(params) {
+        super({ ...params, status: 429, code: 'RATE_LIMIT_EXCEEDED' });
+        this.name = 'RateLimitError';
+        this.retryAfter = params.retryAfter;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Thrown when the API returns a 5xx server error.
+ */
+class ServerError extends FedPulseError {
+    constructor(params) {
+        super({ ...params, status: params.status ?? 500, code: params.code ?? 'INTERNAL_ERROR' });
+        this.name = 'ServerError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ServerError = ServerError;
+/**
+ * Thrown when a network-level failure occurs (DNS, TCP, timeout, ECONNREFUSED).
+ * The `cause` property contains the original error.
+ */
+class NetworkError extends FedPulseError {
+    /** The underlying network error. */
+    cause;
+    constructor(params) {
+        super({ ...params, status: 0, code: 'NETWORK_ERROR' });
+        this.name = 'NetworkError';
+        this.cause = params.cause;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.NetworkError = NetworkError;
+/**
+ * Thrown when a request exceeds the configured timeout.
+ */
+class TimeoutError extends FedPulseError {
+    constructor(params) {
+        super({ ...params, status: 0, code: 'REQUEST_TIMEOUT' });
+        this.name = 'TimeoutError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;
+/**
+ * Thrown when the SDK's retry budget is exhausted.
+ * The `lastError` property contains the final underlying error.
+ */
+class RetryExhaustedError extends FedPulseError {
+    lastError;
+    attempts;
+    constructor(params) {
+        super({
+            message: `Request failed after ${params.attempts} attempt(s): ${params.lastError.message}`,
+            status: params.lastError.status,
+            code: 'RETRY_EXHAUSTED',
+            requestId: params.lastError.requestId,
+        });
+        this.name = 'RetryExhaustedError';
+        this.lastError = params.lastError;
+        this.attempts = params.attempts;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;
+/**
+ * Factory — parses a raw API error response object into the correct error subtype.
+ *
+ * @param status   HTTP response status code.
+ * @param body     Parsed JSON body (may be the error envelope or anything).
+ * @param headers  Response headers map (used for Retry-After).
+ */
+function createApiError(status, body, headers) {
+    // Extract standardised error fields from the envelope.
+    const envelope = body != null && typeof body === 'object' ? body : {};
+    const errObj = envelope['error'] ?? {};
+    const message = typeof errObj['message'] === 'string'
+        ? errObj['message']
+        : typeof envelope['message'] === 'string'
+            ? envelope['message']
+            : `HTTP ${status}`;
+    const code = typeof errObj['code'] === 'string' ? errObj['code'] : undefined;
+    const requestId = typeof envelope['meta']?.['requestId'] === 'string'
+        ? envelope['meta']['requestId']
+        : undefined;
+    const details = errObj['details'] ?? undefined;
+    switch (status) {
+        case 400:
+            return new ValidationError({ message, status: 400, requestId, details });
+        case 401:
+            return new AuthenticationError({ message, requestId, details });
+        case 403:
+            return new PermissionError({ message, code, requestId, details });
+        case 404:
+            return new NotFoundError({ message, requestId, details });
+        case 422:
+            return new ValidationError({ message, status: 422, requestId, details });
+        case 429: {
+            const retryAfterHeader = headers['retry-after'] ?? headers['x-ratelimit-reset'];
+            const retryAfter = retryAfterHeader != null ? Number(retryAfterHeader) : undefined;
+            return new RateLimitError({ message, retryAfter: Number.isFinite(retryAfter) ? retryAfter : undefined, requestId, details });
+        }
+        default:
+            if (status >= 500) {
+                return new ServerError({ message, status, code, requestId, details });
+            }
+            return new FedPulseError({ message, status, code: code ?? 'UNKNOWN_ERROR', requestId, details });
+    }
+}