propline 0.44.0 → 0.46.0

package/dist/index.d.ts

@@ -947,8 +947,52 @@ interface WebhookDelivery {
     attempts: number;
     delivered_at: string | null;
     payload: Record<string, unknown>;
+    /**
+     * This subscription's own event counter — the value sent as the
+     * `X-PropLine-Sequence` header. Null on deliveries enqueued before the
+     * sequence shipped; those cannot be replayed.
+     */
+    seq: number | null;
     [k: string]: unknown;
 }
+/** One event from `replayWebhookEvents`. */
+interface ReplayEvent {
+    /** Cursor position. Monotonic within this subscription. */
+    seq: number;
+    delivery_id: number;
+    event_type: string;
+    created_at: string;
+    /** The canonical payload that was (or would have been) POSTed. */
+    data: Record<string, unknown>;
+}
+interface ReplayPage {
+    webhook_id: number;
+    since_seq: number;
+    /** Oldest first, so you can replay them forward. */
+    events: ReplayEvent[];
+    /**
+     * Cursor for the next call. Equals the `since_seq` you sent when the page
+     * is empty, so a paging loop needs no special case.
+     */
+    next_seq: number;
+    has_more: boolean;
+    /** Bounds of what is still retained. Null when nothing is. */
+    oldest_available_seq: number | null;
+    newest_available_seq: number | null;
+    /**
+     * The most recent sequence ever issued to this subscription. NOT subject to
+     * retention, so `latest_seq - next_seq` is an honest "how far behind am I"
+     * even after the rows themselves are pruned.
+     */
+    latest_seq: number;
+    /**
+     * TRUE when events after your cursor have already aged out and are gone.
+     * Check this: without it a short `events` array is indistinguishable from
+     * "nothing to catch up on".
+     */
+    truncated: boolean;
+    retention_note: string | null;
+}
 interface DfsPayoutTier {
     correct: number;
     multiplier: number;
@@ -1423,6 +1467,33 @@ interface ListWebhookDeliveriesOptions {
      */
     beforeId?: number;
 }
+interface ReplayWebhookEventsOptions {
+    /**
+     * Read events after this cursor — the highest `X-PropLine-Sequence` you
+     * have processed. Defaults to 0 (from the oldest retained event).
+     */
+    sinceSeq?: number;
+    /** Max events per page. Default 100, max 500. */
+    limit?: number;
+}
+interface StreamOptions {
+    /** Subscription to stream. Must be transport="websocket". */
+    webhookId: number;
+    /** Resume point — the last `seq` you processed. Default 0. */
+    sinceSeq?: number;
+    /** Auto-reconnect and resume from the last seq. Default true. */
+    reconnect?: boolean;
+    /** Override the websocket origin (default: derived from baseUrl). */
+    wsUrl?: string;
+    /** Called on every successful handshake with the `ready` frame. */
+    onReady?: (ready: ReplayPage) => void;
+    /**
+     * Called when the server reports events after your cursor have aged out of
+     * retention. This is the one case the stream cannot make you whole —
+     * resync from the REST endpoints.
+     */
+    onTruncated?: (ready: ReplayPage) => void;
+}
 interface VerifySignatureOptions {
     /** Webhook signing secret (returned once from `createWebhook`). */
     secret: string;
@@ -1852,6 +1923,52 @@ declare class PropLine {
     testWebhook(webhookId: number): Promise<unknown>;
     /** Last 50 (default) delivery attempts for a webhook. */
     listWebhookDeliveries(webhookId: number, options?: ListWebhookDeliveriesOptions): Promise<WebhookDelivery[]>;
+    /**
+     * Re-read this subscription's events in order, from a cursor.
+     *
+     * Answers "my endpoint was down — what did I miss?". Every delivery carries
+     * an `X-PropLine-Sequence` header: a counter monotonic *within your
+     * subscription*. Store the highest one you processed and pass it as
+     * `sinceSeq`.
+     *
+     * Do NOT use `X-PropLine-Delivery` as the cursor — that id is global across
+     * every subscription, so its gaps are other customers' traffic.
+     *
+     * Events come back oldest-first (the opposite of `listWebhookDeliveries`,
+     * which is a newest-first debugging log). Page by passing `next_seq` back
+     * as `sinceSeq` while `has_more` is true.
+     *
+     * **Check `truncated`.** True means events after your cursor have aged out
+     * of retention (2 days, max 5,000 deliveries per subscription) and are gone
+     * — resync from the REST endpoints instead of assuming you are current.
+     *
+     * Does not count against your daily request quota.
+     */
+    replayWebhookEvents(webhookId: number, options?: ReplayWebhookEventsOptions): Promise<ReplayPage>;
+    /**
+     * Stream a websocket subscription as an async iterable.
+     *
+     * ```ts
+     * for await (const ev of client.stream({ webhookId: 12, sinceSeq: 4180 })) {
+     *   console.log(ev.seq, ev.event_type, ev.data);
+     * }
+     * ```
+     *
+     * The subscription must have been created with `transport: "websocket"`.
+     * Same events, same filters, same `seq` as an HTTP webhook — one
+     * subscription, different transport.
+     *
+     * **Reconnects automatically and resumes from the last `seq` it saw**, which
+     * is the whole point of the sequence: a dropped connection does not become a
+     * gap in your data. Set `reconnect: false` to get a single connection that
+     * ends when the socket closes.
+     *
+     * If the server reports `truncated` — events after your cursor aged out of
+     * retention and are gone — `onTruncated` fires. Handle it: that is the one
+     * case where the stream cannot make you whole and you should resync from the
+     * REST endpoints.
+     */
+    stream(options: StreamOptions): AsyncGenerator<ReplayEvent, void, void>;
     /**
      * Grade placed bets against their closing lines (CLV).
      *
@@ -1953,6 +2070,6 @@ declare const Bookmakers: {
     readonly PRIZEPICKS: "prizepicks";
 };
 type BookmakerKey = (typeof Bookmakers)[keyof typeof Bookmakers];
-declare const VERSION = "0.44.0";
+declare const VERSION = "0.46.0";
 
-export { AuthError, type BestLine, type BestLineSide, type BestPrice, type Bookmaker, type BookmakerKey, Bookmakers, type CalcEventEvOptions, type ClosingBookmaker, type ClosingMarket, type ClosingOutcome, type ClvBetInput, type ClvGradeResponse, type ClvGradedBet, type ClvSummary, type ContextResponse, type CreateWebhookOptions, type DfsPayoutTier, type DfsPayoutsResponse, type DfsPlayPayout, type EvLine, type EvOutcome, type Event, type EventBestLineResponse, type EventEvCalcResponse, type EventEvResponse, type EventProjectionsResponse, type ExportOddsHistoryOptions, type ExportResolvedPropsOptions, type FuturesEvent, type FuturesMarket, type FuturesOutcome, type GetDfsPayoutsOptions, type GetEventBestLineOptions, type GetEventEvOptions, type GetEventProjectionsOptions, type GetMlbGrandSalamiOptions, type GetNhlDailyGoalsTotalOptions, type GetOddsClosingOptions, type GetOddsHistoryOptions, type GetOddsOptions, type GetPlayerGamesOptions, type GetPlayerHistoryOptions, type GetPlayerTrendsOptions, type GetResultsOptions, type GetScoresOptions, type GetStatsOptions, type HitRateSplit, type ListWebhookDeliveriesOptions, type Market, type MarketSummary, type MlbGrandSalamiBook, type MlbGrandSalamiResponse, type MovementBookmaker, type MovementMarket, type MovementOutcome, type MovementResponse, type NhlDailyGoalsTotalBook, type NhlDailyGoalsTotalResponse, type OddsClosingResponse, type OddsHistoryBookmaker, type OddsHistoryMarket, type OddsHistoryOutcome, type OddsHistoryResponse, type OddsResponse, type Outcome, type OutcomeSnapshot, type PeriodFilter, type PlayerGame, type PlayerGameLog, type PlayerHistoryEntry, type PlayerHistoryResponse, type PlayerMarketTrend, type PlayerStat, type PlayerTrends, type ProjectionRow, PropLine, PropLineError, type PropLineErrorInfo, type PropLineOptions, type QuotaStatus, RateLimitError, type ResolutionSummary, type ResolutionSummaryMarket, type ResolutionSummarySport, type ResolvedOutcome, type ResultsMarket, type ResultsResponse, type ScoreEvent, type Sport, type StatsResponse, type SteamMove, type TrendLastGame, type TrendStreak, type UpdateWebhookOptions, VERSION, type VerifySignatureOptions, type WeatherInfo, type Webhook, type WebhookDelivery, type WebhookEventType };
+export { AuthError, type BestLine, type BestLineSide, type BestPrice, type Bookmaker, type BookmakerKey, Bookmakers, type CalcEventEvOptions, type ClosingBookmaker, type ClosingMarket, type ClosingOutcome, type ClvBetInput, type ClvGradeResponse, type ClvGradedBet, type ClvSummary, type ContextResponse, type CreateWebhookOptions, type DfsPayoutTier, type DfsPayoutsResponse, type DfsPlayPayout, type EvLine, type EvOutcome, type Event, type EventBestLineResponse, type EventEvCalcResponse, type EventEvResponse, type EventProjectionsResponse, type ExportOddsHistoryOptions, type ExportResolvedPropsOptions, type FuturesEvent, type FuturesMarket, type FuturesOutcome, type GetDfsPayoutsOptions, type GetEventBestLineOptions, type GetEventEvOptions, type GetEventProjectionsOptions, type GetMlbGrandSalamiOptions, type GetNhlDailyGoalsTotalOptions, type GetOddsClosingOptions, type GetOddsHistoryOptions, type GetOddsOptions, type GetPlayerGamesOptions, type GetPlayerHistoryOptions, type GetPlayerTrendsOptions, type GetResultsOptions, type GetScoresOptions, type GetStatsOptions, type HitRateSplit, type ListWebhookDeliveriesOptions, type Market, type MarketSummary, type MlbGrandSalamiBook, type MlbGrandSalamiResponse, type MovementBookmaker, type MovementMarket, type MovementOutcome, type MovementResponse, type NhlDailyGoalsTotalBook, type NhlDailyGoalsTotalResponse, type OddsClosingResponse, type OddsHistoryBookmaker, type OddsHistoryMarket, type OddsHistoryOutcome, type OddsHistoryResponse, type OddsResponse, type Outcome, type OutcomeSnapshot, type PeriodFilter, type PlayerGame, type PlayerGameLog, type PlayerHistoryEntry, type PlayerHistoryResponse, type PlayerMarketTrend, type PlayerStat, type PlayerTrends, type ProjectionRow, PropLine, PropLineError, type PropLineErrorInfo, type PropLineOptions, type QuotaStatus, RateLimitError, type ReplayEvent, type ReplayPage, type ReplayWebhookEventsOptions, type ResolutionSummary, type ResolutionSummaryMarket, type ResolutionSummarySport, type ResolvedOutcome, type ResultsMarket, type ResultsResponse, type ScoreEvent, type Sport, type StatsResponse, type SteamMove, type StreamOptions, type TrendLastGame, type TrendStreak, type UpdateWebhookOptions, VERSION, type VerifySignatureOptions, type WeatherInfo, type Webhook, type WebhookDelivery, type WebhookEventType };

package/dist/index.js

@@ -787,6 +787,139 @@ var PropLine = class {
       { params: { limit: options.limit ?? 50, before_id: options.beforeId } }
     );
   }
+  /**
+   * Re-read this subscription's events in order, from a cursor.
+   *
+   * Answers "my endpoint was down — what did I miss?". Every delivery carries
+   * an `X-PropLine-Sequence` header: a counter monotonic *within your
+   * subscription*. Store the highest one you processed and pass it as
+   * `sinceSeq`.
+   *
+   * Do NOT use `X-PropLine-Delivery` as the cursor — that id is global across
+   * every subscription, so its gaps are other customers' traffic.
+   *
+   * Events come back oldest-first (the opposite of `listWebhookDeliveries`,
+   * which is a newest-first debugging log). Page by passing `next_seq` back
+   * as `sinceSeq` while `has_more` is true.
+   *
+   * **Check `truncated`.** True means events after your cursor have aged out
+   * of retention (2 days, max 5,000 deliveries per subscription) and are gone
+   * — resync from the REST endpoints instead of assuming you are current.
+   *
+   * Does not count against your daily request quota.
+   */
+  replayWebhookEvents(webhookId, options = {}) {
+    return this._request(
+      "GET",
+      `/webhooks/${webhookId}/replay`,
+      { params: { since_seq: options.sinceSeq ?? 0, limit: options.limit ?? 100 } }
+    );
+  }
+  /**
+   * Stream a websocket subscription as an async iterable.
+   *
+   * ```ts
+   * for await (const ev of client.stream({ webhookId: 12, sinceSeq: 4180 })) {
+   *   console.log(ev.seq, ev.event_type, ev.data);
+   * }
+   * ```
+   *
+   * The subscription must have been created with `transport: "websocket"`.
+   * Same events, same filters, same `seq` as an HTTP webhook — one
+   * subscription, different transport.
+   *
+   * **Reconnects automatically and resumes from the last `seq` it saw**, which
+   * is the whole point of the sequence: a dropped connection does not become a
+   * gap in your data. Set `reconnect: false` to get a single connection that
+   * ends when the socket closes.
+   *
+   * If the server reports `truncated` — events after your cursor aged out of
+   * retention and are gone — `onTruncated` fires. Handle it: that is the one
+   * case where the stream cannot make you whole and you should resync from the
+   * REST endpoints.
+   */
+  async *stream(options) {
+    const wsBase = (options.wsUrl ?? this.baseUrl).replace(/^http:/, "ws:").replace(/^https:/, "wss:").replace(/\/v1\/?$/, "");
+    const url = `${wsBase}/v1/stream`;
+    let cursor = options.sinceSeq ?? 0;
+    let attempt = 0;
+    for (; ; ) {
+      const queue = [];
+      let notify = null;
+      let closed = null;
+      let opened = false;
+      const ws = new WebSocket(url);
+      const wake = () => {
+        const n = notify;
+        notify = null;
+        n?.();
+      };
+      ws.addEventListener("open", () => {
+        opened = true;
+        ws.send(JSON.stringify({
+          type: "auth",
+          api_key: this.apiKey,
+          webhook_id: options.webhookId,
+          since_seq: cursor
+        }));
+      });
+      ws.addEventListener("message", (e) => {
+        let msg;
+        try {
+          msg = JSON.parse(String(e.data));
+        } catch {
+          return;
+        }
+        if (msg.type === "ready") {
+          attempt = 0;
+          if (msg.truncated) options.onTruncated?.(msg);
+          options.onReady?.(msg);
+        } else if (msg.type === "event") {
+          queue.push(msg);
+          wake();
+        }
+      });
+      ws.addEventListener("close", (e) => {
+        const terminal = [4400, 4401, 4403, 4404].includes(e.code);
+        closed = new PropLineError(
+          e.code,
+          `stream closed${e.reason ? `: ${e.reason}` : ""}`
+        );
+        closed.terminal = terminal;
+        wake();
+      });
+      ws.addEventListener("error", () => {
+        if (!closed) closed = new PropLineError(0, "stream connection error");
+        wake();
+      });
+      try {
+        for (; ; ) {
+          while (queue.length) {
+            const ev = queue.shift();
+            cursor = ev.seq;
+            yield ev;
+          }
+          if (closed) break;
+          await new Promise((r) => {
+            notify = r;
+          });
+        }
+      } finally {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+      const err = closed;
+      if (err?.terminal) throw err;
+      if (options.reconnect === false) {
+        if (err && !opened) throw err;
+        return;
+      }
+      const delayMs = Math.min(3e4, 500 * 2 ** attempt++);
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
   /**
    * Grade placed bets against their closing lines (CLV).
    *
@@ -927,7 +1060,7 @@ var Bookmakers = {
   POLYMARKET: "polymarket",
   PRIZEPICKS: "prizepicks"
 };
-var VERSION = "0.44.0";
+var VERSION = "0.46.0";
 export {
   AuthError,
   Bookmakers,