@fundedfast/sdk 1.3.0 → 1.5.0

package/dist/cjs/resources/admin.d.ts

@@ -1,5 +1,16 @@
 import type { FastClient } from '../client.js';
-import type { AdminBetEvent, BulkSettleResult, WebhookDelivery, AuditEntry, TenantSettings, AdminOverview, BonusOffer, BonusStats, MissionDef, TournamentDef, TournamentLeaderboardEntry, LoyaltyConfig, LoyaltyTier, LoyaltyStats, WebhookEchoEntry, ChallengeTierFull, Ruleset, AdapterMapping, ReconciliationFlag, RewardRule, Reward, SelfExclusionRecord } from '../types.js';
+import type { AdminBetEvent, BulkSettleResult, WebhookDelivery, AuditEntry, TenantSettings, AdminOverview, BonusOffer, BonusStats, MissionDef, TournamentDef, TournamentLeaderboardEntry, LoyaltyConfig, LoyaltyTier, LoyaltyStats, WebhookEchoEntry, ChallengeTierFull, Ruleset, AdapterMapping, ReconciliationFlag, RewardRule, Reward, SelfExclusionRecord, PayoutRequest, PayoutExecution, BetStatus, ChallengeTierCreateRequest, WebhookDeadLetter, WebhookSecretRotation, AuditLogType, AuditLogPage, MissionCreateRequest, TournamentCreateRequest, TournamentEntry, LoyaltyTierCreateRequest, RewardRuleInput, RewardApplication, GrantableRewardType, RewardApplyMode, RulesetCreateRequest, RulesetUpdateRequest, BonusOfferCreateRequest, BonusOfferUpdateRequest, MissionUpdateRequest, LoyaltyConfigUpdateRequest, LoyaltyTierUpdateRequest, AchievementCreateRequest, AchievementUpdateRequest, ThemeUpdateRequest, NotificationPreferencesUpdate, SelfExclusionRequest } from '../types.js';
+/** Body of a manual reward grant. */
+export interface RewardGrantRequest {
+    rewardType: GrantableRewardType;
+    /** In EUR for money types, otherwise percent or days. */
+    value?: number;
+    /** @deprecated Use `value`; the API ignores `rewardValue` on grants. The SDK maps it. */
+    rewardValue?: number;
+    applyMode?: RewardApplyMode;
+    expiresInDays?: number;
+    metadata?: Record<string, unknown>;
+}
 export declare class AdminApi {
     readonly challengeTiers: AdminChallengeTiersApi;
     readonly rulesets: AdminRulesetsApi;
@@ -23,13 +34,14 @@ export declare class AdminApi {
     readonly notificationChannels: AdminNotificationChannelsApi;
     readonly templates: AdminTemplatesApi;
     readonly support: AdminSupportApi;
+    readonly payouts: AdminPayoutsApi;
     constructor(client: FastClient);
 }
 export declare class AdminChallengeTiersApi {
     private readonly client;
     constructor(client: FastClient);
     list(): Promise<ChallengeTierFull[]>;
-    create(data: Partial<ChallengeTierFull>): Promise<ChallengeTierFull>;
+    create(data: ChallengeTierCreateRequest): Promise<ChallengeTierFull>;
     update(id: string, data: Partial<ChallengeTierFull>): Promise<ChallengeTierFull>;
     delete(id: string): Promise<{
         deleted: boolean;
@@ -39,8 +51,8 @@ export declare class AdminRulesetsApi {
     private readonly client;
     constructor(client: FastClient);
     list(): Promise<Ruleset[]>;
-    create(data: Partial<Ruleset>): Promise<Ruleset>;
-    update(id: string, data: Partial<Ruleset>): Promise<Ruleset>;
+    create(data: RulesetCreateRequest): Promise<Ruleset>;
+    update(id: string, data: RulesetUpdateRequest): Promise<Ruleset>;
     delete(id: string): Promise<{
         deleted: boolean;
     }>;
@@ -48,11 +60,16 @@ export declare class AdminRulesetsApi {
 export declare class AdminBetsApi {
     private readonly client;
     constructor(client: FastClient);
+    /** Bet events, newest first (max 200). */
     list(options?: {
-        status?: string;
+        status?: BetStatus;
         userId?: string;
     }): Promise<AdminBetEvent[]>;
     settle(id: string, outcome: 'won' | 'lost'): Promise<AdminBetEvent>;
+    /**
+     * Settle up to 50 placed bets in one call. Each result says `settled` or
+     * `error` (with the reason, e.g. `not_found`, `already_settled`).
+     */
     bulkSettle(settlements: Array<{
         betEventId: string;
         outcome: 'won' | 'lost';
@@ -61,18 +78,55 @@ export declare class AdminBetsApi {
         found: number;
         processed: number;
     }>;
+    /**
+     * Export bet events as CSV (up to 10,000 rows), header line included.
+     *
+     * @param options.from / options.to - full ISO 8601 date-times (e.g. `2026-10-01T00:00:00Z`); a bare date is rejected
+     * @returns The CSV text
+     */
     export(options?: {
         from?: string;
         to?: string;
         userId?: string;
-    }): Promise<Record<string, unknown>>;
+        status?: BetStatus;
+    }): Promise<string>;
+}
+/** Funded payout requests waiting for the operator, and the decision on them. */
+export declare class AdminPayoutsApi {
+    private readonly client;
+    constructor(client: FastClient);
+    list(options?: {
+        status?: 'pending' | 'executed' | 'rejected';
+        userId?: string;
+        limit?: number;
+    }): Promise<PayoutRequest[]>;
+    /**
+     * Execute a pending request: the money moves and the cycle closes.
+     *
+     * @throws {FastApiError} 409 `open_bets` while the account has bets not yet settled; confirm once they have
+     * @throws {FastApiError} 409 `payout_amount_changed` when a full-amount request no longer matches what is available
+     *   (a bet settled since it was made). The request is updated to the new amount; review it and confirm again.
+     * @throws {FastApiError} 409 `payout_request_not_pending` if it was already decided
+     */
+    confirm(id: string): Promise<PayoutExecution>;
+    /** Reject a pending request. Nothing on the account changes. */
+    reject(id: string, reason?: string): Promise<{
+        payoutRequestId: string;
+        status: 'rejected';
+    }>;
 }
 export declare class AdminWebhooksApi {
     private readonly client;
     constructor(client: FastClient);
     list(): Promise<WebhookDelivery[]>;
-    deadLetters(): Promise<WebhookDelivery[]>;
-    replay(id: string): Promise<Record<string, unknown>>;
+    deadLetters(): Promise<WebhookDeadLetter[]>;
+    /**
+     * Replay a dead-lettered webhook delivery.
+     * @throws {FastApiError} 404 `not_found`, 409 `already_replayed`
+     */
+    replay(id: string): Promise<{
+        replayed: boolean;
+    }>;
     /** Retry a failed webhook delivery (resets it to pending and re-dispatches). */
     retry(id: string): Promise<Record<string, unknown>>;
     /**
@@ -83,13 +137,19 @@ export declare class AdminWebhooksApi {
     hookDeadLetters(): Promise<{
         deadLetters: Record<string, unknown>[];
     }>;
-    /** Replay a dead-letter post-bet hook run. Double-counting is prevented server-side. */
+    /**
+     * Replay a dead-letter post-bet hook run. Double-counting is prevented server-side.
+     * @throws {FastApiError} 404 `not_found`, 409 `already_replayed`, 502 `hook_failed` when the hook fails again (a 5xx, so the client's retry policy applies first)
+     */
     replayHook(id: string): Promise<{
         replayed: boolean;
+        outcome: string;
     }>;
-    rotateSecret(): Promise<{
-        webhookSecret: string;
-    }>;
+    /**
+     * Rotate the webhook signing secret. The new secret is in `newSecret` and is
+     * shown only here; the old one stays valid for `gracePeriodHours`.
+     */
+    rotateSecret(): Promise<WebhookSecretRotation>;
     health(): Promise<Record<string, unknown>>;
     echo(limit?: number, eventType?: string): Promise<{
         webhooks: WebhookEchoEntry[];
@@ -104,23 +164,37 @@ export declare class AdminWebhooksApi {
 export declare class AdminAuditApi {
     private readonly client;
     constructor(client: FastClient);
+    /**
+     * Ledger audit view: bet events (`type: 'bets'`, the default) or webhook
+     * deliveries (`type: 'webhooks'`). For the admin action log use {@link adminLog}.
+     */
     list(options?: {
-        type?: string;
+        type?: AuditLogType;
+        userId?: string;
+        from?: string;
+        to?: string;
         limit?: number;
         offset?: number;
-    }): Promise<{
-        entries: AuditEntry[];
-        total: number;
-    }>;
-    /** Admin audit log (different view from /audit/log) */
+    }): Promise<AuditLogPage>;
+    /**
+     * Admin action log: who changed what. Filter by `actor` (an admin email, or
+     * `api-key`), `action`, `resourceType` and a full ISO 8601 `from`/`to`.
+     * `userId` is a deprecated alias of `actor`.
+     */
     adminLog(options?: {
         action?: string;
+        actor?: string;
+        resourceType?: string;
+        from?: string;
+        to?: string; /** @deprecated Use `actor`. */
         userId?: string;
         limit?: number;
         offset?: number;
     }): Promise<{
         entries: AuditEntry[];
         total: number;
+        limit: number;
+        offset: number;
     }>;
     /**
      * Bulk data export (GDPR Art. 20).
@@ -147,7 +221,8 @@ export declare class AdminSettingsApi {
     getIntegrationMode(): Promise<{
         integrationMode: string;
     }>;
-    setWebhookUrl(url: string): Promise<Record<string, unknown>>;
+    /** Set the webhook URL. Pass null to stop deliveries. */
+    setWebhookUrl(url: string | null): Promise<Record<string, unknown>>;
     /**
      * Set the single operator approval URL. FAST calls this one endpoint before any
      * money/irreversible action (purchase, withdrawal, cancel); the action `type` is
@@ -155,17 +230,38 @@ export declare class AdminSettingsApi {
      */
     setApprovalUrl(approvalUrl: string | null): Promise<Record<string, unknown>>;
     setChallengeLimit(limit: number | null): Promise<Record<string, unknown>>;
-    setCurrency(currency: string, symbol?: string): Promise<Record<string, unknown>>;
-    setExposureAlert(threshold: number): Promise<Record<string, unknown>>;
-    configExport(data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Set the default currency (ISO 4217) and, optionally, the list of supported
+     * currencies. The API has no currency symbol setting; a string passed as the
+     * second argument (the old `symbol` parameter) is ignored.
+     */
+    setCurrency(defaultCurrency: string, supportedCurrencies?: string[] | string): Promise<{
+        defaultCurrency: string;
+        supportedCurrencies: string[];
+    }>;
+    /** Set the funded exposure alert threshold. Pass null to disable. */
+    setExposureAlert(threshold: number | null): Promise<Record<string, unknown>>;
+    configExport(data: {
+        exportEnabled: boolean;
+        exportEmail: string | null;
+        exportWebhookUrl: string | null;
+    }): Promise<Record<string, unknown>>;
     /**
      * Presigned download URL for one day's export CSV.
      * @param date Export date as YYYY-MM-DD. Required by the endpoint.
      */
     downloadExport(date: string): Promise<Record<string, unknown>>;
-    testExport(): Promise<Record<string, unknown>>;
+    /**
+     * Generate the daily export now, for yesterday (UTC) or `date` (YYYY-MM-DD).
+     */
+    testExport(date?: string): Promise<{
+        success: boolean;
+        date: string;
+        transactionCount: number;
+        downloadUrl: string | null;
+    }>;
     getTheme(): Promise<Record<string, unknown>>;
-    setTheme(theme: Record<string, unknown>): Promise<Record<string, unknown>>;
+    setTheme(theme: ThemeUpdateRequest): Promise<Record<string, unknown>>;
     clearSnapshots(): Promise<{
         cleared: number;
     }>;
@@ -185,13 +281,16 @@ export declare class AdminBonusesApi {
     private readonly client;
     constructor(client: FastClient);
     listOffers(): Promise<BonusOffer[]>;
-    createOffer(data: Partial<BonusOffer>): Promise<BonusOffer>;
-    updateOffer(id: string, data: Partial<BonusOffer>): Promise<BonusOffer>;
+    createOffer(data: BonusOfferCreateRequest): Promise<BonusOffer>;
+    updateOffer(id: string, data: BonusOfferUpdateRequest): Promise<BonusOffer>;
+    /** Disable an offer. The API keeps the row (sets `enabled: false`) rather than deleting it. */
     deleteOffer(id: string): Promise<{
-        deleted: boolean;
+        disabled: boolean;
     }>;
+    /** Active user bonuses across the tenant. */
     listActive(): Promise<Record<string, unknown>[]>;
     cancel(id: string): Promise<Record<string, unknown>>;
+    /** @param data.depositAmount - Integer cents, like every bonus amount (5000 = 50.00). */
     grantToUser(data: {
         userId: string;
         bonusOfferId: string;
@@ -203,16 +302,18 @@ export declare class AdminBonusesApi {
         available: Record<string, unknown>[];
         completed: Record<string, unknown>[];
     }>;
+    /** @param depositAmount - Integer cents (5000 = 50.00); required for deposit_match and reload offers. */
     activate(userId: string, bonusOfferId: string, depositAmount?: number): Promise<Record<string, unknown>>;
 }
 export declare class AdminMissionsApi {
     private readonly client;
     constructor(client: FastClient);
     list(): Promise<MissionDef[]>;
-    create(data: Partial<MissionDef>): Promise<MissionDef>;
-    update(id: string, data: Partial<MissionDef>): Promise<MissionDef>;
+    create(data: MissionCreateRequest): Promise<MissionDef>;
+    update(id: string, data: MissionUpdateRequest): Promise<MissionDef>;
+    /** Disable a mission. The API keeps the row (sets `enabled: false`) rather than deleting it. */
     delete(id: string): Promise<{
-        deleted: boolean;
+        disabled: boolean;
     }>;
     stats(): Promise<Record<string, unknown>>;
     statsForMission(id: string): Promise<Record<string, unknown>>;
@@ -229,15 +330,23 @@ export declare class AdminTournamentsApi {
     private readonly client;
     constructor(client: FastClient);
     list(): Promise<TournamentDef[]>;
-    create(data: Partial<TournamentDef>): Promise<TournamentDef>;
-    update(id: string, data: Partial<TournamentDef>): Promise<TournamentDef>;
-    /** Cancel an upcoming or active tournament. */
-    cancel(id: string): Promise<Record<string, unknown>>;
+    create(data: TournamentCreateRequest): Promise<TournamentDef>;
+    update(id: string, data: Partial<TournamentCreateRequest>): Promise<TournamentDef>;
+    /**
+     * Cancel an upcoming or active tournament. `cancelled` is false when the
+     * tournament is unknown, already finished or already cancelled.
+     */
+    cancel(id: string): Promise<{
+        cancelled: boolean;
+    }>;
     settle(id: string): Promise<Record<string, unknown>>;
     entries(id: string): Promise<{
-        entries: TournamentLeaderboardEntry[];
+        entries: TournamentEntry[];
+    }>;
+    invite(id: string, userIds: string[]): Promise<{
+        invited: number;
+        alreadyInvited: number;
     }>;
-    invite(id: string, userIds: string[]): Promise<Record<string, unknown>>;
     invites(id: string): Promise<{
         invites: Record<string, unknown>[];
     }>;
@@ -255,21 +364,41 @@ export declare class AdminLoyaltyApi {
     private readonly client;
     constructor(client: FastClient);
     getConfig(): Promise<LoyaltyConfig | null>;
-    setConfig(config: Partial<LoyaltyConfig>): Promise<LoyaltyConfig>;
+    setConfig(config: LoyaltyConfigUpdateRequest): Promise<LoyaltyConfig>;
     getTiers(): Promise<LoyaltyTier[]>;
-    createTier(data: Partial<LoyaltyTier>): Promise<LoyaltyTier>;
-    updateTier(id: string, data: Partial<LoyaltyTier>): Promise<LoyaltyTier>;
+    createTier(data: LoyaltyTierCreateRequest): Promise<LoyaltyTier>;
+    updateTier(id: string, data: LoyaltyTierUpdateRequest): Promise<LoyaltyTier>;
     deleteTier(id: string): Promise<{
         deleted: boolean;
     }>;
+    /**
+     * Users' loyalty state, most points first. Filter by `tier`, the tier
+     * **name**. `tierId` is still accepted: the SDK looks the name up first.
+     */
     listUsers(options?: {
+        tier?: string; /** @deprecated Use `tier` (the tier name). */
         tierId?: string;
         limit?: number;
+        offset?: number;
     }): Promise<{
         users: Record<string, unknown>[];
+        total: number;
+    }>;
+    /** One user's loyalty state and recent point history. `loyalty` is null when the user has none yet. */
+    getUser(userId: string): Promise<{
+        loyalty: Record<string, unknown> | null;
+        history: {
+            entries: Record<string, unknown>[];
+            total: number;
+        };
+    }>;
+    /**
+     * Add (positive) or remove (negative) points. The API records a reason with
+     * every adjustment; when none is given the SDK sends `'Manual adjustment'`.
+     */
+    adjustPoints(userId: string, points: number, reason?: string): Promise<{
+        newTotal: number;
     }>;
-    getUser(userId: string): Promise<Record<string, unknown>>;
-    adjustPoints(userId: string, points: number, reason?: string): Promise<Record<string, unknown>>;
     getPublicTiers(): Promise<LoyaltyTier[]>;
     stats(): Promise<LoyaltyStats>;
     getUserLoyalty(userId: string): Promise<Record<string, unknown> | null>;
@@ -277,25 +406,46 @@ export declare class AdminLoyaltyApi {
 export declare class AdminAnalyticsApi {
     private readonly client;
     constructor(client: FastClient);
-    overview(): Promise<AdminOverview>;
+    /** Dashboard overview for a month (default: the current one). */
+    overview(options?: {
+        month?: number;
+        year?: number;
+    }): Promise<AdminOverview>;
+    /**
+     * Recent API requests for the tenant, newest first (max 200). Filter by
+     * `path` prefix, `status` (e.g. `500`, `4xx`) or `correlationId`.
+     * The API does not paginate; `offset` is ignored.
+     */
     requestLog(options?: {
-        limit?: number;
+        path?: string;
+        status?: string;
+        correlationId?: string;
+        limit?: number; /** @deprecated Not supported by the API. */
         offset?: number;
     }): Promise<{
-        entries: Record<string, unknown>[];
-        total: number;
-    }>;
-    /** Challenge analytics (pass/fail rates, volumes) with optional ISO 8601 date range. */
+        requests: Array<{
+            id: string;
+            method: string;
+            path: string;
+            statusCode: number;
+            durationMs: number;
+            correlationId: string | null;
+            userAgent: string | null;
+            ip: string | null;
+            createdAt: string;
+        }>;
+    }>;
+    /** Challenge analytics (pass/fail rates, volumes). `from`/`to` are full ISO 8601 date-times; a bare date is rejected. */
     challenges(options?: {
         from?: string;
         to?: string;
     }): Promise<Record<string, unknown>>;
-    /** Revenue analytics with optional ISO 8601 date range. */
+    /** Revenue analytics. `from`/`to` are full ISO 8601 date-times; a bare date is rejected. */
     revenue(options?: {
         from?: string;
         to?: string;
     }): Promise<Record<string, unknown>>;
-    /** User cohort analytics with optional ISO 8601 date range. */
+    /** User cohort analytics. `from`/`to` are full ISO 8601 date-times; a bare date is rejected. */
     users(options?: {
         from?: string;
         to?: string;
@@ -333,24 +483,32 @@ export declare class AdminAchievementsApi {
         rarity: string;
         enabled: boolean;
     }>>;
-    create(data: Record<string, unknown>): Promise<Record<string, unknown>>;
-    update(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    create(data: AchievementCreateRequest): Promise<Record<string, unknown>>;
+    update(id: string, data: AchievementUpdateRequest): Promise<Record<string, unknown>>;
     delete(id: string): Promise<{
         deleted: boolean;
     }>;
     forUser(userId: string): Promise<{
         achievements: Record<string, unknown>[];
+        totalPoints: number;
     }>;
+    /** @throws {FastApiError} 409 `already_earned` if the user has it */
     grant(userId: string, achievementId: string): Promise<{
         id: string;
+        tenantId: string;
+        userId: string;
         achievementId: string;
-        grantedAt: string;
+        earnedAt: string;
+        metadata: Record<string, unknown> | null;
     }>;
+    /** Grant one achievement to up to 500 users. Users who already have it are counted in `skipped`. */
     bulkGrant(data: {
         achievementId: string;
         userIds: string[];
     }): Promise<{
         granted: number;
+        skipped: number;
+        results: Array<Record<string, unknown>>;
     }>;
     gdprExport(userId: string): Promise<Record<string, unknown>>;
     gdprErase(userId: string, confirmUserId: string): Promise<Record<string, unknown>>;
@@ -362,7 +520,7 @@ export declare class AdminNotificationsApi {
     private readonly client;
     constructor(client: FastClient);
     getPreferences(): Promise<Record<string, unknown>>;
-    setPreferences(prefs: Record<string, unknown>): Promise<Record<string, unknown>>;
+    setPreferences(prefs: NotificationPreferencesUpdate): Promise<Record<string, unknown>>;
 }
 export declare class AdminRewardsApi {
     private readonly client;
@@ -381,30 +539,34 @@ export declare class AdminRewardsApi {
     history(userId: string, options?: {
         limit?: number;
     }): Promise<{
-        rewards: Reward[];
-        total: number;
+        history: RewardApplication[];
     }>;
-    /** Manually grant a reward to a user. */
-    grant(data: {
+    /**
+     * Manually grant a reward to a user.
+     *
+     * `value` is in EUR for money types, otherwise percent or days.
+     * `rewardValue` is accepted as a deprecated alias of `value`.
+     *
+     * @returns The id of the new pending reward
+     */
+    grant(data: RewardGrantRequest & {
         userId: string;
-        rewardType: string;
-        rewardValue: number;
-        applyMode?: string;
-        expiresInDays?: number;
     }): Promise<{
-        reward: Reward;
+        rewardId: string;
     }>;
-    /** Bulk grant a reward to multiple users. */
-    bulkGrant(data: {
+    /** Grant the same reward to up to 500 users. `rewardValue` is a deprecated alias of `value`. */
+    bulkGrant(data: RewardGrantRequest & {
         userIds: string[];
-        rewardType: string;
-        rewardValue: number;
-        applyMode?: string;
     }): Promise<{
         granted: number;
+        failed: number;
     }>;
-    /** Delete (revoke) a pending reward. */
+    /**
+     * Revoke a pending (unconsumed) reward.
+     * @throws {FastApiError} 404 if it does not exist or was already consumed
+     */
     delete(id: string): Promise<{
+        revoked: boolean; /** @deprecated Use `revoked`. */
         deleted: boolean;
     }>;
 }
@@ -414,9 +576,13 @@ export declare class AdminRewardRulesApi {
     /** List all reward rule definitions. */
     list(): Promise<RewardRule[]>;
     /** Create a new reward rule. */
-    create(data: Partial<RewardRule>): Promise<RewardRule>;
+    /**
+     * Create a reward rule. `name`, `criteria`, `rewardType` and `rewardValue`
+     * are required. The deprecated `triggerType`/`triggerThreshold` are mapped to `criteria`.
+     */
+    create(data: RewardRuleInput & Required<Pick<RewardRuleInput, 'name' | 'rewardType' | 'rewardValue'>>): Promise<RewardRule>;
     /** Update an existing reward rule. */
-    update(id: string, data: Partial<RewardRule>): Promise<RewardRule>;
+    update(id: string, data: RewardRuleInput): Promise<RewardRule>;
     /** Delete a reward rule. */
     delete(id: string): Promise<{
         deleted: boolean;
@@ -425,20 +591,38 @@ export declare class AdminRewardRulesApi {
 export declare class AdminSelfExclusionApi {
     private readonly client;
     constructor(client: FastClient);
-    /** List all currently excluded users. */
-    list(): Promise<{
+    /** List currently excluded users (paginated: limit default 100, max 500). */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        entries: SelfExclusionRecord[];
+        total: number;
+        limit: number;
+        offset: number;
+        /** @deprecated Use `entries`. */
         exclusions: SelfExclusionRecord[];
     }>;
-    /** Get exclusion status for a specific user. Returns 404 if not excluded. */
+    /**
+     * Get the exclusion for a user.
+     * @throws {FastApiError} 404 if the user is not excluded
+     */
     get(userId: string): Promise<SelfExclusionRecord>;
-    /** Exclude a user from purchasing challenges. Upsert: re-excluding updates the record. */
-    exclude(data: {
-        userId: string;
-        reason?: string;
-        durationDays?: number;
-    }): Promise<SelfExclusionRecord>;
-    /** Lift (remove) self-exclusion for a user. */
+    /**
+     * Exclude a user from purchasing challenges. Upsert: re-excluding updates the record.
+     *
+     * Give `expiresAt` (ISO 8601) for a temporary exclusion; omit it (or pass
+     * null) for a permanent one. `durationDays` is converted to `expiresAt`
+     * client-side (now + days).
+     */
+    exclude(data: SelfExclusionRequest): Promise<SelfExclusionRecord>;
+    /**
+     * Lift the exclusion for a user (the record is removed).
+     * @throws {FastApiError} 404 if the user is not excluded
+     */
     lift(userId: string): Promise<{
+        reinstated: boolean;
+        userId: string; /** @deprecated Use `reinstated`. */
         lifted: boolean;
     }>;
 }
@@ -574,14 +758,26 @@ export declare class AdminTemplatesApi {
 export declare class AdminSupportApi {
     private readonly client;
     constructor(client: FastClient);
+    /** Support requests for the tenant. The API does not paginate; `limit` is ignored. */
     list(options?: {
-        status?: string;
+        status?: string; /** @deprecated Not supported by the API. */
         limit?: number;
     }): Promise<{
         requests: Record<string, unknown>[];
     }>;
-    get(id: string): Promise<Record<string, unknown>>;
-    /** Open a new support request. Category defaults to 'other'. */
+    /** A support request with its messages. */
+    get(id: string): Promise<{
+        request: Record<string, unknown>;
+        messages: Record<string, unknown>[];
+    }>;
+    /**
+     * Open a new support request. Category defaults to 'other'.
+     *
+     * @deprecated Needs an admin session: the API records which admin wrote it
+     * and answers 400 `unauthorized` to a server API key. It works only if the
+     * client sends an admin JWT, e.g. `new FastClient({ apiKey, headers: { Authorization: 'Bearer <admin JWT>' } })`.
+     * Open requests from the backoffice instead.
+     */
     create(data: {
         subject: string;
         body: string;
@@ -589,7 +785,12 @@ export declare class AdminSupportApi {
     }): Promise<{
         request: Record<string, unknown>;
     }>;
-    /** Add a message to an existing support request. */
+    /**
+     * Add a message to an existing support request.
+     *
+     * @deprecated Needs an admin session, like {@link create}: a server API key
+     * gets 400 `unauthorized`. Reply from the backoffice instead.
+     */
     addMessage(id: string, body: string): Promise<Record<string, unknown>>;
     /** Close a support request. */
     close(id: string): Promise<Record<string, unknown>>;