@fundedfast/sdk 1.3.0

package/CHANGELOG.md

@@ -0,0 +1,104 @@
+# Changelog
+
+## 1.3.0 (2026-10-06)
+
+First release published to npm.
+
+### Security
+- The client refuses to start in a browser with a server key (`key-...`), which
+  would publish that key to every visitor. Pass `dangerouslyAllowBrowser: true`
+  to override. The public widget key (`pk_...`) is unaffected.
+- The `onRequest` hook receives the API key redacted (`key-***abcd`), so a
+  request logger no longer writes the server key to disk.
+- `verifyWebhookSignature` accepts only a 64-character hex string and rejects
+  anything else before comparing. The doc examples now `await` it: without
+  `await` the result is a Promise, which is always truthy, so every request
+  passed.
+
+### Fixed
+- `downloadExport(date)`, `rewards.list(userId)` and `rewards.history(userId)`
+  send the query parameter the API requires; all three answered 400 before.
+- `admin.audit.export()` documents the 90-day window per call.
+- `User-Agent` reports the real SDK version (it said 1.2.0).
+
+### Added
+- `ChallengePassedProgress`: `users.getProgress()` can return
+  `type: 'challenge_passed'`, with the balance and the continue/refund choices.
+- `WebhookEventType` matches the events the API emits, including
+  `bonus.progress` and `mission.progress`.
+
+## 1.2.0 (2026-07-18)
+
+Alignment release: every SDK method now maps 1:1 to a live API endpoint, and
+all remaining operator-facing endpoints are covered.
+
+### Fixed (previously broken methods)
+
+These methods called endpoints that do not exist in the API and always failed
+with 404; no working integration can be affected by their change or removal:
+
+- `admin.loyalty.setConfig()` now sends `PUT /admin/loyalty/config` (was `POST`, which the API rejects)
+- Removed `admin.challengeTiers.get(id)` - the API has no single-tier GET; use `list()`
+- Removed `admin.rulesets.get(id)` - the API has no single-ruleset GET; use `list()`
+- Removed `admin.reconciliation.forUser(userId)` - use `fast.reconciliation.getForUser(userId)` (the public endpoint)
+- Removed `admin.reconciliation.resolve(userId)` - the API has no flag-resolution endpoint
+- `admin.reconciliation.flags(status?)` now accepts the `open`/`resolved` status filter
+
+### Added - operator (public) namespace
+
+- `users.continueChallenge(userId)` - continue a passed challenge into the Reward (funded) Account
+- `users.refundChallengeStake(userId)` - exit a passed challenge and refund only the own stake (voids the bonus; sends `confirm: true`)
+- `users.refundFundedStake(userId)` - refund the own stake during the funded phase, if the tier allows it (sends `confirm: true`)
+- `users.getTournaments(userId)` - active/upcoming/completed tournament participation
+- `users.getLoyalty(userId)` - loyalty points, tier, and cashback status
+- `fast.widget.getConfig()` - widget module toggles and branding configuration
+
+### Added - admin namespace
+
+- `admin.users.get(userId)` - full user lookup (challenges, funded accounts, bets, achievements, rewards)
+- `admin.users.revokeFunded(userId, reason?)` - manually revoke an active funded account
+- `admin.webhooks.retry(id)` - retry a failed webhook delivery
+- `admin.tournaments.update(id, data)` and `admin.tournaments.cancel(id)`
+- `admin.settings.setWidgetLayout({ fundedOnly?, history? })`
+- `admin.analytics.challenges/revenue/users/benchmarks/engagement/funnel/rewards/leaderboard`
+- `admin.audit.export(options?)` (GDPR Art. 20 bulk export) and `admin.audit.retention()`
+- `admin.notificationChannels` - CRUD + test for Slack/Teams/Discord/custom channels
+- `admin.templates` - browse and clone challenge templates from the FAST marketplace
+- `admin.support` - open, read, message, and close support requests
+
+## 1.0.0 (2026-06-12)
+
+Initial release.
+
+### Features
+
+- Full typed client for all operator-facing FAST API endpoints
+- Automatic retries with exponential backoff and jitter
+- Rate limit awareness (respects Retry-After header)
+- Request/response hooks for observability (logging, metrics, alerting)
+- Idempotency key support for safe retries on mutations
+- Webhook signature verification (async + sync variants)
+- Webhook event parsing with type helpers
+- SSE token issuance and stream URL builder
+- Custom fetch support (for testing/mocking)
+- Debug mode with console logging
+- Dual ESM/CJS builds
+- Zero dependencies
+- Works in Node.js 18+, Deno, Bun, Cloudflare Workers
+
+### API Coverage
+
+- `fast.challenges.listTiers()` - List enabled challenge tiers
+- `fast.challenges.getTierTerms(id)` - Get tier terms and disclosures
+- `fast.challenges.purchase(data)` - Purchase a challenge
+- `fast.bets.validate(bet)` - Validate a bet
+- `fast.bets.ingest(bet)` - Ingest a bet event
+- `fast.bets.ingestBatch(bets)` - Batch ingest (up to 100)
+- `fast.users.getProgress(userId)` - Get user progress
+- `fast.users.getRuleset(userId)` - Get active ruleset
+- `fast.users.getHistory(userId)` - Get challenge/funded account history
+- `fast.users.getWithdrawable(userId)` - Get withdrawable amount
+- `fast.users.withdraw(userId, data)` - Process withdrawal
+- `fast.reconciliation.getForUser(userId, options)` - Reconciliation data
+- `fast.events.issueToken(userId)` - Issue SSE token
+- `fast.events.getStreamUrl(token, userId)` - Build SSE URL

package/README.md

@@ -0,0 +1,352 @@
+# @fundedfast/sdk
+
+Official TypeScript SDK for the [FAST](https://fundedfast.eu) platform API.
+
+Zero dependencies. Automatic retries. Rate limit aware. Works on Node.js 18+, Deno, Bun and Cloudflare Workers. Dual ESM/CJS build, fully typed.
+
+This README is the SDK's API reference. For how the integration fits together (bet flow, webhooks, approvals, the widget, going live), read the integration guide at **[docs.fundedfast.eu](https://docs.fundedfast.eu/integration/quickstart)**.
+
+## Install
+
+```bash
+npm install @fundedfast/sdk
+```
+
+## Constructor
+
+```typescript
+import { FastClient } from '@fundedfast/sdk';
+
+const fast = new FastClient({
+  // Required: your SERVER key (key-...). Never ship it to a browser.
+  apiKey: process.env.FAST_API_KEY!,
+
+  // Optional
+  baseUrl: 'https://api.fundedfast.eu/v1', // default
+  timeout: 10_000,                         // per request, ms (default 10s)
+
+  // Retry (set to false to disable)
+  retry: {
+    maxRetries: 3,                         // default 3
+    initialDelay: 300,                     // ms before first retry (default 300)
+    maxDelay: 10_000,                      // cap between retries (default 10s)
+    retryableStatuses: [429, 500, 502, 503, 504],
+  },
+
+  headers: { 'X-Request-Source': 'my-service' }, // added to every request
+
+  // Observability hooks
+  onRequest: ({ method, url }) => console.log(`FAST ${method} ${url}`),
+  onResponse: ({ status, durationMs, correlationId }) => {
+    if (status >= 500) console.error(`FAST ${status} (${durationMs}ms)`, correlationId);
+  },
+
+  debug: process.env.NODE_ENV === 'development', // logs requests to console
+  // dangerouslyAllowBrowser: true,           // the client refuses to run in a browser with a server key
+  // fetch: myMockFetch,                       // custom fetch, e.g. for tests
+});
+```
+
+Retries back off exponentially with jitter and honour `Retry-After` on 429.
+
+**Idempotency.** Every `POST` the SDK sends carries an `X-Idempotency-Key`, generated per call and reused across that call's retries. The money endpoints that require one (`users.withdraw`, `users.refundChallengeStake`, `users.refundFundedStake`) therefore work without you passing anything, and an SDK retry can never pay twice. The key does not survive across separate calls you make: if your process crashes mid-payout, check the account state before calling again. See [Withdrawals](https://docs.fundedfast.eu/integration/withdrawals).
+
+## Quick start
+
+```typescript
+const tiers = await fast.challenges.listTiers();
+
+const challenge = await fast.challenges.purchase({
+  userId: 'player-42',
+  challengeTierId: tiers[0].id,
+});
+
+const bet = {
+  userId: 'player-42',
+  externalBetId: 'BET-001',
+  stakeAmount: 5.0,
+  odds: 2.1,
+  status: 'placed' as const,
+};
+
+const { status, reasonCodes } = await fast.bets.validate(bet);
+if (status === 'accepted') {
+  await fast.bets.ingest(bet);
+}
+```
+
+When to validate, what to send on settlement and how sync/async modes differ: [Bet Events](https://docs.fundedfast.eu/integration/bet-events).
+
+## Operator namespaces
+
+| Namespace | Methods |
+|---|---|
+| `challenges` | `listTiers()`, `getTierTerms(tierId)`, `purchase({ userId, challengeTierId })`, `leaderboard(period?, limit?)` |
+| `bets` | `validate(bet)`, `ingest(bet)`, `ingestBatch(bets)` (max 100) |
+| `users` | `getProgress`, `getRuleset`, `getHistory`, `getWithdrawable`, `withdraw`, `getTimeline`, `getAchievements`, `getRewards`, `claimReward`, `notifyWithdrawal`, `continueChallenge`, `refundChallengeStake`, `refundFundedStake`, `cancelChallenge`, `cancelFundedAccount`, `getTournaments`, `getLoyalty` |
+| `reconciliation` | `getForUser(userId, { from?, to? })` |
+| `events` | `issueToken(userId)`, `getStreamUrl(token, userId)` |
+| `widget` | `getConfig()` |
+| `sandbox` | `reset()`, `resetUser(userId)` (staging tenants only) |
+| `admin.*` | see [Admin API](#admin-api) |
+
+### Bets
+
+```typescript
+// Settlement
+await fast.bets.ingest({
+  userId: 'player-42',
+  externalBetId: 'BET-001',
+  stakeAmount: 5.0,
+  odds: 2.1,
+  status: 'settled-won',
+  settlementAmount: 10.5,
+});
+
+// Batch (partial success: check result.results for per-bet status)
+const result = await fast.bets.ingestBatch([bet]);
+console.log(`${result.processed}/${result.total} processed, ${result.failed} failed`);
+```
+
+### User progress
+
+`getProgress` returns a discriminated union. Narrow on `type`:
+
+```typescript
+const progress = await fast.users.getProgress('player-42');
+
+switch (progress.type) {
+  case 'challenge':
+    console.log(`${progress.currentBalance}/${progress.targetBalance}, ${progress.daysRemaining}d left`);
+    break;
+  case 'challenge_passed':
+    // Target reached; the user must choose. progress.choices is ['continue', 'refund']
+    console.log(`Passed. Refundable own stake: ${progress.refundableOwnStake}`);
+    break;
+  case 'funded_account':
+    console.log(`Withdrawable: ${progress.withdrawableProfit}`);
+    break;
+  case 'none':
+    console.log('No active position');
+    break;
+}
+```
+
+Field meanings: [User Progress](https://docs.fundedfast.eu/integration/user-progress).
+
+### Continue or exit a passed challenge
+
+```typescript
+// Continue into the funded account
+const { fundedAccountId } = await fast.users.continueChallenge('player-42');
+
+// Or exit with the own stake (irreversible; the SDK sends confirm: true)
+const { ownStake, bonusAmount } = await fast.users.refundChallengeStake('player-42');
+
+// During the funded phase, only on tiers with fundedStakeRefundable
+const refund = await fast.users.refundFundedStake('player-42');
+```
+
+FAST records the outcome and emits the webhook; your sportsbook moves the money.
+
+### Withdrawals
+
+```typescript
+const info = await fast.users.getWithdrawable('player-42');
+if (info.activeDaysMet && info.withdrawable > 0) {
+  const { userPayout, operatorShare, newBalance } = await fast.users.withdraw('player-42', {
+    amount: info.withdrawable,
+  });
+}
+```
+
+How the profit split is deducted and the errors to handle: [Withdrawals](https://docs.fundedfast.eu/integration/withdrawals).
+
+### Real-time events (SSE)
+
+```typescript
+// Backend, with the server key: mint a per-user token (1 hour)
+const { token, expiresAt } = await fast.events.issueToken('player-42');
+
+// Hand the token to the browser; it connects with
+const url = fast.events.getStreamUrl(token, 'player-42');
+// new EventSource(url)
+```
+
+The same token is what the widget takes as `data-user-token`. Event names and payloads: [Real-Time Events](https://docs.fundedfast.eu/integration/real-time-events).
+
+### Reconciliation
+
+```typescript
+const data = await fast.reconciliation.getForUser('player-42', {
+  from: '2026-06-01T00:00:00Z',
+  to: '2026-06-30T23:59:59Z',
+});
+// data.betEvents, data.challenge, data.fundedAccount
+```
+
+## Webhook verification
+
+FAST signs each delivery with HMAC-SHA256 over the **raw request body**, using your webhook secret, and sends the hex digest in the `X-Webhook-Signature` header. Verify against the raw bytes: re-serialising parsed JSON changes them and the check fails.
+
+```typescript
+import express from 'express';
+import { verifyWebhookSignature, parseWebhookEvent } from '@fundedfast/sdk/webhooks';
+
+const app = express();
+
+app.post('/webhooks/fast', express.raw({ type: 'application/json' }), async (req, res) => {
+  const rawBody = req.body.toString('utf-8');
+  const signature = req.header('x-webhook-signature') ?? '';
+
+  // Async: uses node:crypto, or Web Crypto on edge runtimes. Timing-safe.
+  if (!(await verifyWebhookSignature(rawBody, signature, process.env.FAST_WEBHOOK_SECRET!))) {
+    return res.status(401).send('Invalid signature');
+  }
+
+  const event = parseWebhookEvent(rawBody); // { eventId, eventType, userId, timestamp, data }
+  switch (event.eventType) {
+    case 'challenge.passed':
+    case 'funded_account.payout':
+    case 'cooldown.triggered':
+      // ...
+      break;
+  }
+
+  res.status(200).json({ received: true });
+});
+```
+
+`@fundedfast/sdk/webhooks` also exports `isChallengeEvent`, `isFundedAccountEvent` and `isUserEvent`. `WebhookEventType` lists every event FAST emits. What each event means, retries and deduplication by `eventId`: [Webhook Handling](https://docs.fundedfast.eu/integration/webhook-handling) and [Webhook Events](https://docs.fundedfast.eu/api/webhook-events).
+
+## Errors
+
+```typescript
+import { FastApiError, FastTimeoutError, FastNetworkError } from '@fundedfast/sdk';
+
+try {
+  await fast.challenges.purchase({ userId: 'x', challengeTierId: 'y' });
+} catch (err) {
+  if (err instanceof FastApiError) {
+    err.status;          // 400, 404, 409, 429, 500...
+    err.code;            // 'validation_error', 'conflict', 'rate_limited', ...
+    err.message;         // human-readable
+    err.correlationId;   // quote this to support
+    err.isRetryable;     // true for 429 and 5xx
+    err.rateLimitReset;  // ms from Retry-After, when present
+  } else if (err instanceof FastTimeoutError) {
+    err.timeoutMs;
+  } else if (err instanceof FastNetworkError) {
+    err.cause;           // the underlying error (DNS, connection refused, ...)
+  }
+}
+```
+
+The SDK throws only after its retries are exhausted. Code list: [Error Codes](https://docs.fundedfast.eu/api/error-codes).
+
+## Types
+
+Every request and response type is exported:
+
+```typescript
+import type {
+  Challenge,
+  ChallengeTier,
+  UserProgress,
+  ChallengeProgress,
+  ChallengePassedProgress,
+  FundedAccountProgress,
+  ValidationResult,
+  BetEvent,
+  WebhookPayload,
+  WebhookEventType,
+} from '@fundedfast/sdk';
+```
+
+```typescript
+// ESM
+import { FastClient } from '@fundedfast/sdk';
+// CommonJS
+const { FastClient } = require('@fundedfast/sdk');
+```
+
+## Admin API
+
+The `admin` namespace covers the operator backoffice, with the same server key.
+
+```typescript
+// Challenge tiers (no single-tier GET: use list())
+const tiers = await fast.admin.challengeTiers.list();
+await fast.admin.challengeTiers.update(tierId, { enabled: false });
+
+// Templates (marketplace bundles you can clone into your tenant)
+const { templates } = await fast.admin.templates.list();
+await fast.admin.templates.clone(templateId, { tierName: 'Starter 100', ownStake: 100 });
+
+// Bets
+const bets = await fast.admin.bets.list({ status: 'placed', userId: 'player-42' });
+await fast.admin.bets.settle(betId, 'won');
+await fast.admin.bets.bulkSettle([{ betEventId: betId, outcome: 'won' }]);
+
+// Webhooks
+await fast.admin.webhooks.retry(deliveryId);
+const dead = await fast.admin.webhooks.deadLetters();
+await fast.admin.webhooks.replay(deadLetterId);
+await fast.admin.webhooks.rotateSecret();
+const { deadLetters } = await fast.admin.webhooks.hookDeadLetters(); // post-bet hook failures
+await fast.admin.webhooks.replayHook(hookRunId);
+
+// Settings
+await fast.admin.settings.setIntegrationMode('async');
+await fast.admin.settings.setWebhookUrl('https://my.backend/webhooks');
+await fast.admin.settings.setCurrency('USD', '$');
+
+// Engagement
+await fast.admin.bonuses.activate('player-42', offerId);
+await fast.admin.tournaments.settle(tournamentId);
+await fast.admin.loyalty.adjustPoints('player-42', 500, 'VIP bonus');
+await fast.admin.rewards.grant({ userId: 'player-42', rewardType: 'balance_bonus', rewardValue: 10 });
+await fast.admin.achievements.bulkGrant({ achievementId, userIds: ['player-42'] });
+
+// Compliance and support
+await fast.admin.selfExclusion.exclude({ userId: 'player-42', reason: 'request' });
+await fast.admin.users.revokeFunded('player-42', 'manual_operator_revoke');
+const { flags } = await fast.admin.reconciliation.flags('open');
+const auditLog = await fast.admin.audit.list({ type: 'webhooks', limit: 50 });
+await fast.admin.achievements.gdprErase('player-42', 'player-42'); // second arg confirms the id
+const { request } = await fast.admin.support.create({
+  subject: 'Webhook retries stuck', body: 'Since 14:00 UTC...', category: 'technical',
+});
+```
+
+| Namespace | Methods |
+|---|---|
+| `admin.challengeTiers` | list, create, update, delete |
+| `admin.rulesets` | list, create, update, delete |
+| `admin.bets` | list, settle, bulkSettle, bulkExpire, export |
+| `admin.webhooks` | list, retry, deadLetters, replay, rotateSecret, health, echo, clearEcho, hookDeadLetters, replayHook |
+| `admin.audit` | list, adminLog, export, retention |
+| `admin.settings` | get, getIntegrationMode, setIntegrationMode, setWebhookUrl, setApprovalUrl, setChallengeLimit, setCurrency, setExposureAlert, setWidgetLayout, configExport, downloadExport, testExport, getTheme, setTheme, clearSnapshots |
+| `admin.bonuses` | listOffers, createOffer, updateOffer, deleteOffer, listActive, cancel, grantToUser, stats, getUserBonuses, activate |
+| `admin.missions` | list, create, update, delete, stats, statsForMission, getUserMissions, join |
+| `admin.tournaments` | list, create, update, cancel, settle, entries, invite, invites, stats, listPublic, leaderboard, join |
+| `admin.loyalty` | getConfig, setConfig, getTiers, createTier, updateTier, deleteTier, listUsers, getUser, adjustPoints, getPublicTiers, stats, getUserLoyalty |
+| `admin.analytics` | overview, requestLog, challenges, revenue, users, benchmarks, engagement, funnel, rewards, leaderboard |
+| `admin.achievements` | list, create, update, delete, forUser, grant, bulkGrant, gdprExport, gdprErase |
+| `admin.notifications` | getPreferences, setPreferences |
+| `admin.notificationChannels` | list, create, update, delete, test |
+| `admin.rewards` | list, history, grant, bulkGrant, delete |
+| `admin.rewardRules` | list, create, update, delete |
+| `admin.selfExclusion` | list, get, exclude, lift |
+| `admin.adapters` | list, create, update, delete |
+| `admin.reconciliation` | flags |
+| `admin.users` | get, revokeFunded |
+| `admin.templates` | list, get, clone |
+| `admin.support` | list, get, create, addMessage, close |
+
+## Links
+
+- Integration guide: https://docs.fundedfast.eu/integration/quickstart
+- Getting access (keys, staging, production): https://docs.fundedfast.eu/integration/getting-access
+- API reference (OpenAPI, try-it-out): https://api.fundedfast.eu/v1/docs
+- Support: support@fundedfast.eu

package/dist/cjs/client.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @fundedfast/sdk - Client
+ *
+ * Production-grade HTTP client for the FAST platform API.
+ * Features: automatic retries with exponential backoff, rate limit awareness,
+ * request/response hooks, idempotency support, debug logging, and proper error handling.
+ *
+ * @example
+ * ```typescript
+ * import { FastClient } from '@fundedfast/sdk';
+ *
+ * const fast = new FastClient({
+ *   apiKey: process.env.FAST_API_KEY!,
+ *   retry: { maxRetries: 3 },
+ *   onResponse: ({ status, durationMs, correlationId }) => {
+ *     metrics.histogram('fast.request.duration', durationMs, { status });
+ *   },
+ * });
+ *
+ * const result = await fast.bets.validate({
+ *   userId: 'player-42',
+ *   externalBetId: 'BET-001',
+ *   stakeAmount: 5.00,
+ *   odds: 2.10,
+ *   status: 'placed',
+ * });
+ * ```
+ *
+ * @module client
+ */
+import type { FastClientConfig, FastError } from './types.js';
+import { ChallengesApi, BetsApi, UsersApi, ReconciliationApi, EventsApi, SandboxApi, WidgetApi } from './resources/public.js';
+import { AdminApi } from './resources/admin.js';
+export declare const SDK_VERSION = "1.3.0";
+/**
+ * Error thrown when the FAST API returns a non-2xx response.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fast.challenges.purchase({ userId: 'x', challengeTierId: 'invalid' });
+ * } catch (err) {
+ *   if (err instanceof FastApiError) {
+ *     console.log(err.status);        // 400
+ *     console.log(err.code);          // 'validation_error'
+ *     console.log(err.correlationId); // 'abc-123' (for support)
+ *     console.log(err.isRetryable);   // false
+ *   }
+ * }
+ * ```
+ */
+export declare class FastApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly correlationId: string;
+    readonly isRetryable: boolean;
+    readonly rateLimitReset?: number;
+    constructor(status: number, body: FastError, rateLimitReset?: number);
+}
+/**
+ * Error thrown when a request times out.
+ */
+export declare class FastTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/**
+ * Error thrown when a network error occurs (DNS, connection refused, etc.)
+ */
+export declare class FastNetworkError extends Error {
+    readonly cause: Error;
+    constructor(cause: Error);
+}
+/**
+ * FAST Platform API client.
+ *
+ * Provides typed access to all operator-facing endpoints with automatic retry,
+ * rate limit handling, and observability hooks.
+ *
+ * @example
+ * ```typescript
+ * const fast = new FastClient({ apiKey: 'key-...' });
+ *
+ * // Namespaced APIs
+ * const tiers = await fast.challenges.listTiers();
+ * const result = await fast.bets.validate(betEvent);
+ * const progress = await fast.users.getProgress('player-42');
+ * ```
+ */
+export declare class FastClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly retryConfig;
+    private readonly onRequest?;
+    private readonly onResponse?;
+    private readonly _fetch;
+    private readonly customHeaders;
+    private readonly debug;
+    /** Challenge purchase and tier management */
+    readonly challenges: ChallengesApi;
+    /** Bet validation and ingestion */
+    readonly bets: BetsApi;
+    /** User progress, history, and withdrawals */
+    readonly users: UsersApi;
+    /** Bet event reconciliation */
+    readonly reconciliation: ReconciliationApi;
+    /** Real-time event streaming (SSE) */
+    readonly events: EventsApi;
+    /** Sandbox operations (staging only) */
+    readonly sandbox: SandboxApi;
+    /** Widget module and branding configuration */
+    readonly widget: WidgetApi;
+    /** Admin / backoffice operations (tenant management) */
+    readonly admin: AdminApi;
+    constructor(config: FastClientConfig);
+    /**
+     * Execute an authenticated request against the FAST API.
+     * Handles retries, timeouts, rate limits, and hooks automatically.
+     *
+     * @internal Use the namespaced APIs (challenges, bets, users, etc.) instead.
+     */
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        query?: Record<string, string | undefined>;
+        idempotencyKey?: string;
+    }): Promise<T>;
+    private calculateDelay;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EAIV,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,aAAa,EACb,OAAO,EACP,QAAQ,EACR,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,SAAS,EACV,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAQhD,eAAO,MAAM,WAAW,UAAU,CAAC;AAgCnC;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,WAAW,EAAE,OAAO,CAAC;IACrC,SAAgB,cAAc,CAAC,EAAE,MAAM,CAAC;gBAE5B,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,CAAC,EAAE,MAAM;CASrE;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAEtB,SAAS,EAAE,MAAM;CAK9B;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,SAAgB,KAAK,EAAE,KAAK,CAAC;gBAEjB,KAAK,EAAE,KAAK;CAKzB;AAMD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAc;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAe;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;IACvD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;IAEhC,6CAA6C;IAC7C,SAAgB,UAAU,EAAE,aAAa,CAAC;IAC1C,mCAAmC;IACnC,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,8CAA8C;IAC9C,SAAgB,KAAK,EAAE,QAAQ,CAAC;IAChC,+BAA+B;IAC/B,SAAgB,cAAc,EAAE,iBAAiB,CAAC;IAClD,sCAAsC;IACtC,SAAgB,MAAM,EAAE,SAAS,CAAC;IAClC,wCAAwC;IACxC,SAAgB,OAAO,EAAE,UAAU,CAAC;IACpC,+CAA+C;IAC/C,SAAgB,MAAM,EAAE,SAAS,CAAC;IAClC,wDAAwD;IACxD,SAAgB,KAAK,EAAE,QAAQ,CAAC;gBAEpB,MAAM,EAAE,gBAAgB;IAwCpC;;;;;OAKG;IACG,OAAO,CAAC,CAAC,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;QAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,GACA,OAAO,CAAC,CAAC,CAAC;IAgKb,OAAO,CAAC,cAAc;CASvB"}