@0xarchive/sdk 0.5.4 → 0.6.1

package/README.md

@@ -308,6 +308,68 @@ const lighterCandles = await client.lighter.candles.history('BTC', {
 | `1d` | 1 day |
 | `1w` | 1 week |
 
+### Data Quality Monitoring
+
+Monitor data coverage, incidents, latency, and SLA compliance across all exchanges.
+
+```typescript
+// Get overall system health status
+const status = await client.dataQuality.status();
+console.log(`System status: ${status.status}`);
+for (const [exchange, info] of Object.entries(status.exchanges)) {
+  console.log(`  ${exchange}: ${info.status}`);
+}
+
+// Get data coverage summary for all exchanges
+const coverage = await client.dataQuality.coverage();
+for (const exchange of coverage.exchanges) {
+  console.log(`${exchange.exchange}:`);
+  for (const [dtype, info] of Object.entries(exchange.dataTypes)) {
+    console.log(`  ${dtype}: ${info.totalRecords.toLocaleString()} records, ${info.completeness}% complete`);
+  }
+}
+
+// Get symbol-specific coverage with gap detection
+const btc = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC');
+const oi = btc.dataTypes.open_interest;
+console.log(`BTC OI completeness: ${oi.completeness}%`);
+console.log(`Gaps found: ${oi.gaps.length}`);
+for (const gap of oi.gaps.slice(0, 5)) {
+  console.log(`  ${gap.durationMinutes} min gap: ${gap.start} -> ${gap.end}`);
+}
+
+// List incidents with filtering
+const result = await client.dataQuality.listIncidents({ status: 'open' });
+for (const incident of result.incidents) {
+  console.log(`[${incident.severity}] ${incident.title}`);
+}
+
+// Get latency metrics
+const latency = await client.dataQuality.latency();
+for (const [exchange, metrics] of Object.entries(latency.exchanges)) {
+  console.log(`${exchange}: OB lag ${metrics.dataFreshness.orderbookLagMs}ms`);
+}
+
+// Get SLA compliance metrics for a specific month
+const sla = await client.dataQuality.sla({ year: 2026, month: 1 });
+console.log(`Period: ${sla.period}`);
+console.log(`Uptime: ${sla.actual.uptime}% (${sla.actual.uptimeStatus})`);
+console.log(`API P99: ${sla.actual.apiLatencyP99Ms}ms (${sla.actual.latencyStatus})`);
+```
+
+#### Data Quality Endpoints
+
+| Method | Description |
+|--------|-------------|
+| `status()` | Overall system health and per-exchange status |
+| `coverage()` | Data coverage summary for all exchanges |
+| `exchangeCoverage(exchange)` | Coverage details for a specific exchange |
+| `symbolCoverage(exchange, symbol)` | Coverage with gap detection for specific symbol |
+| `listIncidents(params)` | List incidents with filtering and pagination |
+| `getIncident(incidentId)` | Get specific incident details |
+| `latency()` | Current latency metrics (WebSocket, REST, data freshness) |
+| `sla(params)` | SLA compliance metrics for a specific month |
+
 ### Legacy API (Deprecated)
 
 The following legacy methods are deprecated and will be removed in v2.0. They default to Hyperliquid data:
@@ -457,6 +519,31 @@ ws.stream('orderbook', 'BTC', {
 ws.streamStop();
 ```
 
+### Gap Detection
+
+During historical replay and bulk streaming, the server automatically detects gaps in the data and notifies the client. This helps identify periods where data may be missing.
+
+```typescript
+// Handle gap notifications during replay/stream
+ws.onGap((channel, coin, gapStart, gapEnd, durationMinutes) => {
+  console.log(`Gap detected in ${channel}/${coin}:`);
+  console.log(`  From: ${new Date(gapStart).toISOString()}`);
+  console.log(`  To: ${new Date(gapEnd).toISOString()}`);
+  console.log(`  Duration: ${durationMinutes} minutes`);
+});
+
+// Start replay - gaps will be reported via onGap callback
+ws.replay('orderbook', 'BTC', {
+  start: Date.now() - 86400000,
+  end: Date.now(),
+  speed: 10
+});
+```
+
+Gap thresholds vary by channel:
+- **orderbook**, **candles**, **liquidations**: 2 minutes
+- **trades**: 60 minutes (trades can naturally have longer gaps during low activity periods)
+
 ### WebSocket Configuration
 
 ```typescript
@@ -477,6 +564,7 @@ const ws = new OxArchiveWs({
 | `orderbook` | L2 order book updates | Yes | Yes |
 | `trades` | Trade/fill updates | Yes | Yes |
 | `candles` | OHLCV candle data | Yes | Yes (replay/stream only) |
+| `liquidations` | Liquidation events (May 2025+) | Yes | Yes (replay/stream only) |
 | `ticker` | Price and 24h volume | Yes | Real-time only |
 | `all_tickers` | All market tickers | No | Real-time only |
 

package/dist/index.d.mts

@@ -536,8 +536,24 @@ interface WsStreamStopped {
     type: 'stream_stopped';
     snapshots_sent: number;
 }
+/**
+ * Gap detected in historical data stream.
+ * Sent when there's a gap exceeding the threshold between consecutive data points.
+ * Thresholds: 2 minutes for orderbook/candles/liquidations, 60 minutes for trades.
+ */
+interface WsGapDetected {
+    type: 'gap_detected';
+    channel: WsChannel;
+    coin: string;
+    /** Start of the gap (last data point timestamp in ms) */
+    gap_start: number;
+    /** End of the gap (next data point timestamp in ms) */
+    gap_end: number;
+    /** Gap duration in minutes */
+    duration_minutes: number;
+}
 /** Server message union type */
-type WsServerMessage = WsSubscribed | WsUnsubscribed | WsPong | WsError | WsData | WsReplayStarted | WsReplayPaused | WsReplayResumed | WsReplayCompleted | WsReplayStopped | WsHistoricalData | WsHistoricalTickData | WsStreamStarted | WsStreamProgress | WsHistoricalBatch | WsStreamCompleted | WsStreamStopped;
+type WsServerMessage = WsSubscribed | WsUnsubscribed | WsPong | WsError | WsData | WsReplayStarted | WsReplayPaused | WsReplayResumed | WsReplayCompleted | WsReplayStopped | WsHistoricalData | WsHistoricalTickData | WsStreamStarted | WsStreamProgress | WsHistoricalBatch | WsStreamCompleted | WsStreamStopped | WsGapDetected;
 /**
  * WebSocket connection options.
  *
@@ -586,6 +602,265 @@ declare class OxArchiveError extends Error {
 }
 /** Timestamp can be Unix ms (number), ISO string, or Date object */
 type Timestamp = number | string | Date;
+/** System status values */
+type SystemStatusValue = 'operational' | 'degraded' | 'outage' | 'maintenance';
+/** Status of a single exchange */
+interface ExchangeStatus {
+    /** Current status */
+    status: SystemStatusValue;
+    /** Timestamp of last received data */
+    lastDataAt?: string;
+    /** Current latency in milliseconds */
+    latencyMs?: number;
+}
+/** Status of a data type (orderbook, fills, etc.) */
+interface DataTypeStatus {
+    /** Current status */
+    status: SystemStatusValue;
+    /** Data completeness over last 24 hours (0-100) */
+    completeness24h: number;
+}
+/** Overall system status response */
+interface StatusResponse {
+    /** Overall system status */
+    status: SystemStatusValue;
+    /** When this status was computed */
+    updatedAt: string;
+    /** Per-exchange status */
+    exchanges: Record<string, ExchangeStatus>;
+    /** Per-data-type status */
+    dataTypes: Record<string, DataTypeStatus>;
+    /** Number of active incidents */
+    activeIncidents: number;
+}
+/** Coverage information for a specific data type */
+interface DataTypeCoverage {
+    /** Earliest available data timestamp */
+    earliest: string;
+    /** Latest available data timestamp */
+    latest: string;
+    /** Total number of records */
+    totalRecords: number;
+    /** Number of symbols with data */
+    symbols: number;
+    /** Data resolution (e.g., '1.2s', '1m') */
+    resolution?: string;
+    /** Current data lag */
+    lag?: string;
+    /** Completeness percentage (0-100) */
+    completeness: number;
+}
+/** Coverage for a single exchange */
+interface ExchangeCoverage {
+    /** Exchange name */
+    exchange: string;
+    /** Coverage per data type */
+    dataTypes: Record<string, DataTypeCoverage>;
+}
+/** Overall coverage response */
+interface CoverageResponse {
+    /** Coverage for all exchanges */
+    exchanges: ExchangeCoverage[];
+}
+/** Gap information for per-symbol coverage */
+interface CoverageGap {
+    /** Start of the gap (last data before gap) */
+    start: string;
+    /** End of the gap (first data after gap) */
+    end: string;
+    /** Duration of the gap in minutes */
+    durationMinutes: number;
+}
+/** Coverage for a specific symbol and data type */
+interface SymbolDataTypeCoverage {
+    /** Earliest available data timestamp */
+    earliest: string;
+    /** Latest available data timestamp */
+    latest: string;
+    /** Total number of records */
+    totalRecords: number;
+    /** Completeness percentage (0-100) */
+    completeness: number;
+    /** Detected data gaps */
+    gaps: CoverageGap[];
+}
+/** Per-symbol coverage response */
+interface SymbolCoverageResponse {
+    /** Exchange name */
+    exchange: string;
+    /** Symbol name */
+    symbol: string;
+    /** Coverage per data type */
+    dataTypes: Record<string, SymbolDataTypeCoverage>;
+}
+/** Incident status values */
+type IncidentStatusValue = 'open' | 'investigating' | 'identified' | 'monitoring' | 'resolved';
+/** Incident severity values */
+type IncidentSeverityValue = 'minor' | 'major' | 'critical';
+/** Data quality incident */
+interface Incident {
+    /** Unique incident ID */
+    id: string;
+    /** Status: open, investigating, identified, monitoring, resolved */
+    status: string;
+    /** Severity: minor, major, critical */
+    severity: string;
+    /** Affected exchange (if specific to one) */
+    exchange?: string;
+    /** Affected data types */
+    dataTypes: string[];
+    /** Affected symbols */
+    symbolsAffected: string[];
+    /** When the incident started */
+    startedAt: string;
+    /** When the incident was resolved */
+    resolvedAt?: string;
+    /** Total duration in minutes */
+    durationMinutes?: number;
+    /** Incident title */
+    title: string;
+    /** Detailed description */
+    description?: string;
+    /** Root cause analysis */
+    rootCause?: string;
+    /** Resolution details */
+    resolution?: string;
+    /** Number of records affected */
+    recordsAffected?: number;
+    /** Number of records recovered */
+    recordsRecovered?: number;
+}
+/** Pagination info for incident list */
+interface Pagination {
+    /** Total number of incidents */
+    total: number;
+    /** Page size limit */
+    limit: number;
+    /** Current offset */
+    offset: number;
+}
+/** Incidents list response */
+interface IncidentsResponse {
+    /** List of incidents */
+    incidents: Incident[];
+    /** Pagination info */
+    pagination: Pagination;
+}
+/** WebSocket latency metrics */
+interface WebSocketLatency {
+    /** Current latency */
+    currentMs: number;
+    /** 1-hour average latency */
+    avg1hMs: number;
+    /** 24-hour average latency */
+    avg24hMs: number;
+    /** 24-hour P99 latency */
+    p9924hMs?: number;
+}
+/** REST API latency metrics */
+interface RestApiLatency {
+    /** Current latency */
+    currentMs: number;
+    /** 1-hour average latency */
+    avg1hMs: number;
+    /** 24-hour average latency */
+    avg24hMs: number;
+}
+/** Data freshness metrics (lag from source) */
+interface DataFreshness {
+    /** Orderbook data lag */
+    orderbookLagMs?: number;
+    /** Fills/trades data lag */
+    fillsLagMs?: number;
+    /** Funding rate data lag */
+    fundingLagMs?: number;
+    /** Open interest data lag */
+    oiLagMs?: number;
+}
+/** Latency metrics for a single exchange */
+interface ExchangeLatency {
+    /** WebSocket latency metrics */
+    websocket?: WebSocketLatency;
+    /** REST API latency metrics */
+    restApi?: RestApiLatency;
+    /** Data freshness metrics */
+    dataFreshness: DataFreshness;
+}
+/** Overall latency response */
+interface LatencyResponse {
+    /** When these metrics were measured */
+    measuredAt: string;
+    /** Per-exchange latency metrics */
+    exchanges: Record<string, ExchangeLatency>;
+}
+/** SLA targets */
+interface SlaTargets {
+    /** Uptime target percentage */
+    uptime: number;
+    /** Data completeness target percentage */
+    dataCompleteness: number;
+    /** API P99 latency target in milliseconds */
+    apiLatencyP99Ms: number;
+}
+/** Completeness metrics per data type */
+interface CompletenessMetrics {
+    /** Orderbook completeness percentage */
+    orderbook: number;
+    /** Fills completeness percentage */
+    fills: number;
+    /** Funding rate completeness percentage */
+    funding: number;
+    /** Overall completeness percentage */
+    overall: number;
+}
+/** Actual SLA metrics */
+interface SlaActual {
+    /** Actual uptime percentage */
+    uptime: number;
+    /** 'met' or 'missed' */
+    uptimeStatus: string;
+    /** Actual completeness metrics */
+    dataCompleteness: CompletenessMetrics;
+    /** 'met' or 'missed' */
+    completenessStatus: string;
+    /** Actual API P99 latency */
+    apiLatencyP99Ms: number;
+    /** 'met' or 'missed' */
+    latencyStatus: string;
+}
+/** SLA compliance response */
+interface SlaResponse {
+    /** Period covered (e.g., '2026-01') */
+    period: string;
+    /** Target SLA metrics */
+    slaTargets: SlaTargets;
+    /** Actual SLA metrics */
+    actual: SlaActual;
+    /** Number of incidents in this period */
+    incidentsThisPeriod: number;
+    /** Total downtime in minutes */
+    totalDowntimeMinutes: number;
+}
+/** Parameters for listing incidents */
+interface ListIncidentsParams {
+    /** Filter by incident status */
+    status?: IncidentStatusValue;
+    /** Filter by exchange */
+    exchange?: string;
+    /** Only show incidents starting after this timestamp (Unix ms) */
+    since?: number | string;
+    /** Maximum results per page (default: 20, max: 100) */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+}
+/** Parameters for getting SLA metrics */
+interface SlaParams {
+    /** Year (defaults to current year) */
+    year?: number;
+    /** Month 1-12 (defaults to current month) */
+    month?: number;
+}
 
 interface HttpClientOptions {
     baseUrl: string;
@@ -1026,6 +1301,165 @@ declare class LiquidationsResource {
     byUser(userAddress: string, params: LiquidationsByUserParams): Promise<CursorResponse<Liquidation[]>>;
 }
 
+/**
+ * Data quality API resource
+ *
+ * Provides endpoints for monitoring data quality, coverage, incidents, and SLA metrics.
+ *
+ * @example
+ * ```typescript
+ * // Get system status
+ * const status = await client.dataQuality.status();
+ * console.log(`System status: ${status.status}`);
+ *
+ * // Get coverage for all exchanges
+ * const coverage = await client.dataQuality.coverage();
+ *
+ * // Get symbol-specific coverage with gap detection
+ * const btc = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC');
+ * console.log(`BTC OI completeness: ${btc.dataTypes.open_interest.completeness}%`);
+ * for (const gap of btc.dataTypes.open_interest.gaps.slice(0, 5)) {
+ *   console.log(`Gap: ${gap.start} - ${gap.end} (${gap.durationMinutes} min)`);
+ * }
+ * ```
+ */
+declare class DataQualityResource {
+    private http;
+    private basePath;
+    constructor(http: HttpClient, basePath?: string);
+    /**
+     * Get overall system health status
+     *
+     * @returns StatusResponse with overall status, per-exchange status,
+     *          per-data-type status, and active incident count
+     *
+     * @example
+     * ```typescript
+     * const status = await client.dataQuality.status();
+     * console.log(`Overall: ${status.status}`);
+     * for (const [exchange, info] of Object.entries(status.exchanges)) {
+     *   console.log(`${exchange}: ${info.status}`);
+     * }
+     * ```
+     */
+    status(): Promise<StatusResponse>;
+    /**
+     * Get data coverage summary for all exchanges
+     *
+     * @returns CoverageResponse with coverage info for all exchanges and data types
+     *
+     * @example
+     * ```typescript
+     * const coverage = await client.dataQuality.coverage();
+     * for (const exchange of coverage.exchanges) {
+     *   console.log(`${exchange.exchange}:`);
+     *   for (const [dtype, info] of Object.entries(exchange.dataTypes)) {
+     *     console.log(`  ${dtype}: ${info.totalRecords} records`);
+     *   }
+     * }
+     * ```
+     */
+    coverage(): Promise<CoverageResponse>;
+    /**
+     * Get data coverage for a specific exchange
+     *
+     * @param exchange - Exchange name ('hyperliquid' or 'lighter')
+     * @returns ExchangeCoverage with coverage info for all data types on this exchange
+     *
+     * @example
+     * ```typescript
+     * const hl = await client.dataQuality.exchangeCoverage('hyperliquid');
+     * console.log(`Orderbook earliest: ${hl.dataTypes.orderbook.earliest}`);
+     * ```
+     */
+    exchangeCoverage(exchange: string): Promise<ExchangeCoverage>;
+    /**
+     * Get data coverage for a specific symbol on an exchange
+     *
+     * Includes gap detection showing periods where data may be missing.
+     *
+     * @param exchange - Exchange name ('hyperliquid' or 'lighter')
+     * @param symbol - Symbol name (e.g., 'BTC', 'ETH')
+     * @returns SymbolCoverageResponse with per-data-type coverage including gaps
+     *
+     * @example
+     * ```typescript
+     * const btc = await client.dataQuality.symbolCoverage('hyperliquid', 'BTC');
+     * const oi = btc.dataTypes.open_interest;
+     * console.log(`OI completeness: ${oi.completeness}%`);
+     * console.log(`Gaps found: ${oi.gaps.length}`);
+     * for (const gap of oi.gaps.slice(0, 3)) {
+     *   console.log(`  ${gap.durationMinutes} min gap at ${gap.start}`);
+     * }
+     * ```
+     */
+    symbolCoverage(exchange: string, symbol: string): Promise<SymbolCoverageResponse>;
+    /**
+     * List incidents with filtering and pagination
+     *
+     * @param params - Filter and pagination options
+     * @returns IncidentsResponse with list of incidents and pagination info
+     *
+     * @example
+     * ```typescript
+     * // Get all open incidents
+     * const result = await client.dataQuality.listIncidents({ status: 'open' });
+     * for (const incident of result.incidents) {
+     *   console.log(`${incident.severity}: ${incident.title}`);
+     * }
+     * ```
+     */
+    listIncidents(params?: ListIncidentsParams): Promise<IncidentsResponse>;
+    /**
+     * Get a specific incident by ID
+     *
+     * @param incidentId - The incident ID
+     * @returns Incident details
+     *
+     * @example
+     * ```typescript
+     * const incident = await client.dataQuality.getIncident('inc_123');
+     * console.log(`Status: ${incident.status}`);
+     * console.log(`Root cause: ${incident.rootCause}`);
+     * ```
+     */
+    getIncident(incidentId: string): Promise<Incident>;
+    /**
+     * Get current latency metrics for all exchanges
+     *
+     * @returns LatencyResponse with WebSocket, REST API, and data freshness metrics
+     *
+     * @example
+     * ```typescript
+     * const latency = await client.dataQuality.latency();
+     * for (const [exchange, metrics] of Object.entries(latency.exchanges)) {
+     *   console.log(`${exchange}:`);
+     *   if (metrics.websocket) {
+     *     console.log(`  WS current: ${metrics.websocket.currentMs}ms`);
+     *   }
+     *   console.log(`  OB lag: ${metrics.dataFreshness.orderbookLagMs}ms`);
+     * }
+     * ```
+     */
+    latency(): Promise<LatencyResponse>;
+    /**
+     * Get SLA compliance metrics for a specific month
+     *
+     * @param params - Optional year and month (defaults to current month)
+     * @returns SlaResponse with SLA targets, actual metrics, and compliance status
+     *
+     * @example
+     * ```typescript
+     * const sla = await client.dataQuality.sla({ year: 2026, month: 1 });
+     * console.log(`Period: ${sla.period}`);
+     * console.log(`Uptime: ${sla.actual.uptime}% (${sla.actual.uptimeStatus})`);
+     * console.log(`Completeness: ${sla.actual.dataCompleteness.overall}%`);
+     * console.log(`API P99: ${sla.actual.apiLatencyP99Ms}ms`);
+     * ```
+     */
+    sla(params?: SlaParams): Promise<SlaResponse>;
+}
+
 /**
  * Hyperliquid exchange client
  *
@@ -1158,6 +1592,10 @@ declare class OxArchive {
      * Lighter.xyz exchange data (August 2025+)
      */
     readonly lighter: LighterClient;
+    /**
+     * Data quality metrics: status, coverage, incidents, latency, SLA
+     */
+    readonly dataQuality: DataQualityResource;
     /**
      * @deprecated Use client.hyperliquid.orderbook instead
      */
@@ -1257,6 +1695,7 @@ declare class OxArchiveWs {
     private streamCompleteHandlers;
     private orderbookHandlers;
     private tradesHandlers;
+    private gapHandlers;
     constructor(options: WsOptions);
     /**
      * Connect to the WebSocket server
@@ -1418,6 +1857,23 @@ declare class OxArchiveWs {
      * Handle stream completed event
      */
     onStreamComplete(handler: (channel: WsChannel, coin: string, snapshotsSent: number) => void): void;
+    /**
+     * Handle gap detected events during replay or streaming.
+     * Called when there's a gap in the historical data exceeding the threshold.
+     * Thresholds: 2 minutes for orderbook/candles/liquidations, 60 minutes for trades.
+     *
+     * @param handler - Callback receiving channel, coin, gap start/end timestamps (ms), and duration (minutes)
+     *
+     * @example
+     * ```typescript
+     * ws.onGap((channel, coin, gapStart, gapEnd, durationMinutes) => {
+     *   console.warn(`Gap detected in ${channel} ${coin}: ${durationMinutes} minutes`);
+     *   console.warn(`  From: ${new Date(gapStart).toISOString()}`);
+     *   console.warn(`  To:   ${new Date(gapEnd).toISOString()}`);
+     * });
+     * ```
+     */
+    onGap(handler: (channel: WsChannel, coin: string, gapStart: number, gapEnd: number, durationMinutes: number) => void): void;
     /**
      * Get current connection state
      */
@@ -1788,8 +2244,8 @@ declare const CandleSchema: z.ZodObject<{
     quoteVolume: z.ZodOptional<z.ZodNumber>;
     tradeCount: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    timestamp: string;
     open: number;
+    timestamp: string;
     high: number;
     low: number;
     close: number;
@@ -1797,8 +2253,8 @@ declare const CandleSchema: z.ZodObject<{
     quoteVolume?: number | undefined;
     tradeCount?: number | undefined;
 }, {
-    timestamp: string;
     open: number;
+    timestamp: string;
     high: number;
     low: number;
     close: number;
@@ -3082,8 +3538,8 @@ declare const CandleArrayResponseSchema: z.ZodObject<{
         quoteVolume: z.ZodOptional<z.ZodNumber>;
         tradeCount: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        timestamp: string;
         open: number;
+        timestamp: string;
         high: number;
         low: number;
         close: number;
@@ -3091,8 +3547,8 @@ declare const CandleArrayResponseSchema: z.ZodObject<{
         quoteVolume?: number | undefined;
         tradeCount?: number | undefined;
     }, {
-        timestamp: string;
         open: number;
+        timestamp: string;
         high: number;
         low: number;
         close: number;
@@ -3115,8 +3571,8 @@ declare const CandleArrayResponseSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     data: {
-        timestamp: string;
         open: number;
+        timestamp: string;
         high: number;
         low: number;
         close: number;
@@ -3132,8 +3588,8 @@ declare const CandleArrayResponseSchema: z.ZodObject<{
     };
 }, {
     data: {
-        timestamp: string;
         open: number;
+        timestamp: string;
         high: number;
         low: number;
         close: number;
@@ -3257,4 +3713,4 @@ type ValidatedCandle = z.infer<typeof CandleSchema>;
 type ValidatedLiquidation = z.infer<typeof LiquidationSchema>;
 type ValidatedWsServerMessage = z.infer<typeof WsServerMessageSchema>;
 
-export { type ApiError, type ApiMeta, ApiMetaSchema, type ApiResponse, ApiResponseSchema, type Candle, CandleArrayResponseSchema, type CandleHistoryParams, type CandleInterval, CandleIntervalSchema, CandleSchema, type ClientOptions, type CursorResponse, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, HyperliquidClient, type Instrument, InstrumentArrayResponseSchema, InstrumentResponseSchema, InstrumentSchema, type InstrumentType, InstrumentTypeSchema, LighterClient, type LighterGranularity, type LighterInstrument, type Liquidation, LiquidationArrayResponseSchema, type LiquidationHistoryParams, LiquidationSchema, LiquidationSideSchema, type LiquidationsByUserParams, type OpenInterest, OpenInterestArrayResponseSchema, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookResponseSchema, OrderBookSchema, OxArchive, OxArchiveError, OxArchiveWs, type PriceLevel, PriceLevelSchema, type Timestamp, type TimestampedRecord, TimestampedRecordSchema, type Trade, TradeArrayResponseSchema, type TradeDirection, TradeDirectionSchema, TradeSchema, type TradeSide, TradeSideSchema, type ValidatedApiMeta, type ValidatedCandle, type ValidatedFundingRate, type ValidatedInstrument, type ValidatedLiquidation, type ValidatedOpenInterest, type ValidatedOrderBook, type ValidatedPriceLevel, type ValidatedTrade, type ValidatedWsServerMessage, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, type WsHistoricalBatch, WsHistoricalBatchSchema, type WsHistoricalData, WsHistoricalDataSchema, type WsOptions, type WsPing, type WsPong, WsPongSchema, type WsReplay, type WsReplayCompleted, WsReplayCompletedSchema, type WsReplayPause, type WsReplayPaused, WsReplayPausedSchema, type WsReplayResume, type WsReplayResumed, WsReplayResumedSchema, type WsReplaySeek, type WsReplayStarted, WsReplayStartedSchema, type WsReplayStop, type WsReplayStopped, WsReplayStoppedSchema, type WsServerMessage, WsServerMessageSchema, type WsStream, type WsStreamCompleted, WsStreamCompletedSchema, type WsStreamProgress, WsStreamProgressSchema, type WsStreamStarted, WsStreamStartedSchema, type WsStreamStop, type WsStreamStopped, WsStreamStoppedSchema, type WsSubscribe, type WsSubscribed, WsSubscribedSchema, type WsUnsubscribe, type WsUnsubscribed, WsUnsubscribedSchema, OxArchive as default };
+export { type ApiError, type ApiMeta, ApiMetaSchema, type ApiResponse, ApiResponseSchema, type Candle, CandleArrayResponseSchema, type CandleHistoryParams, type CandleInterval, CandleIntervalSchema, CandleSchema, type ClientOptions, type CompletenessMetrics, type CoverageGap, type CoverageResponse, type CursorResponse, type DataFreshness, type DataTypeCoverage, type DataTypeStatus, type ExchangeCoverage, type ExchangeLatency, type ExchangeStatus, type FundingRate, FundingRateArrayResponseSchema, FundingRateResponseSchema, FundingRateSchema, type GetOrderBookParams, type GetTradesCursorParams, HyperliquidClient, type Incident, type IncidentSeverityValue, type IncidentStatusValue, type IncidentsResponse, type Instrument, InstrumentArrayResponseSchema, InstrumentResponseSchema, InstrumentSchema, type InstrumentType, InstrumentTypeSchema, type LatencyResponse, LighterClient, type LighterGranularity, type LighterInstrument, type Liquidation, LiquidationArrayResponseSchema, type LiquidationHistoryParams, LiquidationSchema, LiquidationSideSchema, type LiquidationsByUserParams, type ListIncidentsParams, type OpenInterest, OpenInterestArrayResponseSchema, OpenInterestResponseSchema, OpenInterestSchema, type OrderBook, OrderBookArrayResponseSchema, type OrderBookHistoryParams, OrderBookResponseSchema, OrderBookSchema, OxArchive, OxArchiveError, OxArchiveWs, type Pagination, type PriceLevel, PriceLevelSchema, type RestApiLatency, type SlaActual, type SlaParams, type SlaResponse, type SlaTargets, type StatusResponse, type SymbolCoverageResponse, type SymbolDataTypeCoverage, type SystemStatusValue, type Timestamp, type TimestampedRecord, TimestampedRecordSchema, type Trade, TradeArrayResponseSchema, type TradeDirection, TradeDirectionSchema, TradeSchema, type TradeSide, TradeSideSchema, type ValidatedApiMeta, type ValidatedCandle, type ValidatedFundingRate, type ValidatedInstrument, type ValidatedLiquidation, type ValidatedOpenInterest, type ValidatedOrderBook, type ValidatedPriceLevel, type ValidatedTrade, type ValidatedWsServerMessage, type WebSocketLatency, type WsChannel, WsChannelSchema, type WsClientMessage, type WsConnectionState, WsConnectionStateSchema, type WsData, WsDataSchema, type WsError, WsErrorSchema, type WsEventHandlers, type WsHistoricalBatch, WsHistoricalBatchSchema, type WsHistoricalData, WsHistoricalDataSchema, type WsOptions, type WsPing, type WsPong, WsPongSchema, type WsReplay, type WsReplayCompleted, WsReplayCompletedSchema, type WsReplayPause, type WsReplayPaused, WsReplayPausedSchema, type WsReplayResume, type WsReplayResumed, WsReplayResumedSchema, type WsReplaySeek, type WsReplayStarted, WsReplayStartedSchema, type WsReplayStop, type WsReplayStopped, WsReplayStoppedSchema, type WsServerMessage, WsServerMessageSchema, type WsStream, type WsStreamCompleted, WsStreamCompletedSchema, type WsStreamProgress, WsStreamProgressSchema, type WsStreamStarted, WsStreamStartedSchema, type WsStreamStop, type WsStreamStopped, WsStreamStoppedSchema, type WsSubscribe, type WsSubscribed, WsSubscribedSchema, type WsUnsubscribe, type WsUnsubscribed, WsUnsubscribedSchema, OxArchive as default };