propheseer 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,857 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Rate limit information extracted from API response headers.
+ */
+interface RateLimitInfo {
+    /** User's plan (free, pro, business, etc.) */
+    plan: string;
+    /** Billing type: 'subscription' or 'credits' */
+    billingType: 'subscription' | 'credits';
+    /** Daily request limit (subscription billing) */
+    limitDay?: number;
+    /** Remaining daily requests (subscription billing) */
+    remainingDay?: number;
+    /** Per-minute request limit (subscription billing) */
+    limitMinute?: number;
+    /** Remaining per-minute requests (subscription billing) */
+    remainingMinute?: number;
+    /** Credit balance in cents (credit billing) */
+    creditBalanceCents?: number;
+    /** Formatted credit balance (credit billing) */
+    creditBalance?: string;
+    /** Cost of the request in cents (credit billing) */
+    requestCostCents?: number;
+    /** Formatted request cost (credit billing) */
+    requestCost?: string;
+}
+/**
+ * Wrapper for API responses that includes rate limit info.
+ */
+interface APIResponse<T> {
+    /** The response data */
+    data: T;
+    /** Rate limit information from response headers */
+    rateLimit: RateLimitInfo | null;
+    /** The raw Response object */
+    response: Response;
+}
+/**
+ * Pagination metadata returned by paginated endpoints.
+ */
+interface PaginationMeta {
+    /** Total number of items matching the query */
+    total: number;
+    /** Maximum items per page */
+    limit: number;
+    /** Current offset */
+    offset: number;
+    /** Source metadata (varies by endpoint) */
+    sources?: Record<string, unknown>;
+}
+
+interface ClientOptions {
+    /** API key for authentication. Falls back to PROPHESEER_API_KEY env var. */
+    apiKey?: string;
+    /** Base URL for the API (default: https://api.propheseer.com) */
+    baseURL?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum number of retries on retryable errors (default: 2) */
+    maxRetries?: number;
+}
+interface RequestConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    /** Whether this request requires authentication (default: true) */
+    auth?: boolean;
+}
+/**
+ * Base HTTP client with retry logic, rate limit parsing, and error mapping.
+ */
+declare class BaseClient {
+    readonly apiKey: string | undefined;
+    readonly baseURL: string;
+    readonly timeout: number;
+    readonly maxRetries: number;
+    constructor(options?: ClientOptions);
+    /**
+     * Make an authenticated API request with retry and error handling.
+     */
+    request<T>(config: RequestConfig): Promise<{
+        data: T;
+        rateLimit: RateLimitInfo | null;
+        response: Response;
+    }>;
+    private buildURL;
+    private getRetryDelay;
+}
+
+/** Prediction market data sources */
+type MarketSource = 'polymarket' | 'kalshi' | 'gemini';
+/** Market status */
+type MarketStatus = 'open' | 'closed' | 'settled';
+/** Market category */
+type MarketCategory = 'politics' | 'sports' | 'finance' | 'entertainment' | 'science' | 'other';
+/**
+ * An outcome within a prediction market.
+ */
+interface Outcome {
+    /** Outcome name (e.g. "Yes", "No", "Donald Trump") */
+    name: string;
+    /** Probability as a decimal between 0 and 1 */
+    probability: number;
+    /** 24-hour trading volume (null if unavailable) */
+    volume24h: number | null;
+}
+/**
+ * A normalized prediction market from any supported platform.
+ */
+interface Market {
+    /** Unique market ID (prefixed: pm_, ks_, gm_) */
+    id: string;
+    /** Source platform */
+    source: MarketSource;
+    /** Original ID on the source platform */
+    sourceId: string;
+    /** The market question */
+    question: string;
+    /** Market description (may be null) */
+    description: string | null;
+    /** Normalized category */
+    category: MarketCategory;
+    /** Market status */
+    status: MarketStatus;
+    /** Available outcomes with probabilities */
+    outcomes: Outcome[];
+    /** Expected resolution date (ISO 8601, may be null) */
+    resolutionDate: string | null;
+    /** When the market was created (ISO 8601) */
+    createdAt: string;
+    /** When the market was last updated (ISO 8601) */
+    updatedAt: string;
+    /** URL to the market on its source platform */
+    url: string;
+    /** Market image URL (may be null) */
+    imageUrl: string | null;
+    /** Tags from the source platform */
+    tags: string[];
+}
+/**
+ * Parameters for listing markets.
+ */
+interface MarketListParams {
+    /** Filter by source platform */
+    source?: MarketSource | 'all';
+    /** Filter by category */
+    category?: MarketCategory;
+    /** Filter by status */
+    status?: MarketStatus;
+    /** Search query string */
+    q?: string;
+    /** Maximum results per page (default: 50, max: 200) */
+    limit?: number;
+    /** Offset for pagination (default: 0) */
+    offset?: number;
+}
+
+/**
+ * A page of results from a paginated API endpoint.
+ */
+declare class Page<T> {
+    /** Items on this page */
+    readonly data: T[];
+    /** Pagination metadata */
+    readonly meta: PaginationMeta;
+    /** Rate limit information */
+    readonly rateLimit: RateLimitInfo | null;
+    constructor(data: T[], meta: PaginationMeta, rateLimit: RateLimitInfo | null);
+    /** Whether there are more pages available */
+    hasMore(): boolean;
+    /** The offset for the next page, or null if no more pages */
+    nextOffset(): number | null;
+}
+/**
+ * Options for auto-pagination.
+ */
+interface AutoPaginateOptions {
+    /** Maximum total items to yield (default: unlimited) */
+    maxItems?: number;
+}
+/**
+ * Creates an async generator that automatically paginates through all results.
+ *
+ * @param fetchPage - Function that fetches a page given an offset
+ * @param options - Auto-pagination options
+ * @returns AsyncGenerator yielding individual items
+ */
+declare function autoPaginate<T>(fetchPage: (offset: number) => Promise<Page<T>>, options?: AutoPaginateOptions): AsyncGenerator<T, void, undefined>;
+
+declare class Markets {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List markets with optional filters.
+     *
+     * @example
+     * ```ts
+     * const page = await client.markets.list({ source: 'polymarket', limit: 10 });
+     * console.log(page.data); // Market[]
+     * console.log(page.meta.total); // total matching markets
+     * ```
+     */
+    list(params?: MarketListParams): Promise<Page<Market>>;
+    /**
+     * Get a single market by ID.
+     *
+     * @example
+     * ```ts
+     * const { data: market } = await client.markets.get('pm_12345');
+     * ```
+     */
+    get(id: string): Promise<APIResponse<Market>>;
+    /**
+     * Auto-paginate through all markets matching the query.
+     *
+     * @example
+     * ```ts
+     * for await (const market of client.markets.listAutoPaginate({ source: 'kalshi' })) {
+     *   console.log(market.question);
+     * }
+     * ```
+     */
+    listAutoPaginate(params?: Omit<MarketListParams, 'offset'>, options?: AutoPaginateOptions): AsyncGenerator<Market, void, undefined>;
+}
+
+/**
+ * A market category with its subcategories.
+ */
+interface Category {
+    /** Category identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** List of subcategory identifiers */
+    subcategories: string[];
+}
+
+declare class Categories {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List all available market categories.
+     *
+     * @example
+     * ```ts
+     * const { data: categories } = await client.categories.list();
+     * ```
+     */
+    list(): Promise<APIResponse<Category[]>>;
+}
+
+/**
+ * A market involved in an arbitrage opportunity.
+ */
+interface ArbitrageMarket {
+    /** Source platform */
+    source: MarketSource;
+    /** Yes price (probability) */
+    yesPrice: number;
+    /** URL to the market */
+    url: string;
+}
+/**
+ * An arbitrage opportunity across platforms.
+ */
+interface ArbitrageOpportunity {
+    /** The market question */
+    question: string;
+    /** Price spread between platforms (decimal) */
+    spread: number;
+    /** Potential return percentage (e.g. "5.2%") */
+    potentialReturn: string;
+    /** Markets involved in the opportunity */
+    markets: ArbitrageMarket[];
+}
+/**
+ * Parameters for finding arbitrage opportunities.
+ */
+interface ArbitrageFindParams {
+    /** Minimum spread to include (default: 0.03) */
+    minSpread?: number;
+    /** Filter by category */
+    category?: MarketCategory;
+}
+
+declare class Arbitrage {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * Find arbitrage opportunities across platforms.
+     * Requires Pro plan or higher.
+     *
+     * @example
+     * ```ts
+     * const { data: opportunities } = await client.arbitrage.find({ minSpread: 0.05 });
+     * for (const opp of opportunities) {
+     *   console.log(`${opp.question}: ${opp.potentialReturn}`);
+     * }
+     * ```
+     */
+    find(params?: ArbitrageFindParams): Promise<APIResponse<ArbitrageOpportunity[]>>;
+}
+
+/** Reasons a trade was flagged as unusual */
+type DetectionReason = 'potential_insider' | 'high_amount' | 'new_wallet' | 'near_resolution';
+/** Trade side */
+type TradeSide = 'BUY' | 'SELL';
+/**
+ * Market information associated with an unusual trade.
+ */
+interface UnusualTradeMarket {
+    /** Market ID */
+    id: string;
+    /** Market question */
+    question: string;
+    /** Source platform */
+    source: MarketSource;
+    /** Market end date (may be undefined) */
+    endDate?: string;
+    /** URL to the market */
+    url?: string;
+    /** Tags from the platform */
+    tags: string[];
+    /** Market image URL */
+    imageUrl?: string | null;
+}
+/**
+ * Details of the flagged trade.
+ */
+interface TradeDetails {
+    /** Trader's wallet address */
+    walletAddress: string;
+    /** Buy or sell */
+    side: TradeSide;
+    /** Trade size (contracts) */
+    size: number;
+    /** Trade price */
+    price: number;
+    /** USDC value of the trade */
+    usdcValue: number;
+    /** When the trade occurred (ISO 8601) */
+    timestamp: string;
+    /** On-chain transaction hash */
+    transactionHash: string;
+}
+/**
+ * Why the trade was flagged.
+ */
+interface DetectionInfo {
+    /** Detection reason */
+    reason: DetectionReason;
+    /** Anomaly score (0-100) */
+    anomalyScore: number;
+    /** Market context for the detection */
+    context: {
+        /** Average trade size in this market */
+        marketAvgSize: number;
+        /** Standard deviation of trade sizes */
+        marketStdDev: number;
+    };
+}
+/**
+ * An unusual trade detected by the system.
+ */
+interface UnusualTrade {
+    /** Trade ID */
+    id: string;
+    /** Associated market */
+    market: UnusualTradeMarket;
+    /** Trade details */
+    trade: TradeDetails;
+    /** Detection information */
+    detection: DetectionInfo;
+    /** When the trade was detected (ISO 8601) */
+    detectedAt: string;
+}
+/**
+ * Parameters for listing unusual trades.
+ */
+interface UnusualTradeListParams {
+    /** Maximum results per page (default: 50, max: 100) */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Filter by market ID */
+    marketId?: string;
+    /** Filter by detection reason */
+    reason?: DetectionReason;
+    /** Minimum anomaly score */
+    minScore?: number;
+    /** Only trades since this date (ISO 8601) */
+    since?: string;
+    /** Filter by trade side */
+    side?: TradeSide;
+    /** Filter by source platform */
+    source?: MarketSource;
+    /** Categories to exclude (comma-separated) */
+    excludeCategories?: string;
+}
+
+declare class UnusualTrades {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List unusual trades detected by the system.
+     * Requires Pro plan or higher.
+     *
+     * @example
+     * ```ts
+     * const page = await client.unusualTrades.list({ reason: 'high_amount', limit: 10 });
+     * for (const trade of page.data) {
+     *   console.log(`${trade.market.question}: $${trade.trade.usdcValue}`);
+     * }
+     * ```
+     */
+    list(params?: UnusualTradeListParams): Promise<Page<UnusualTrade>>;
+    /**
+     * Auto-paginate through all unusual trades matching the query.
+     *
+     * @example
+     * ```ts
+     * for await (const trade of client.unusualTrades.listAutoPaginate({ since: '2025-01-01' })) {
+     *   console.log(trade.detection.reason);
+     * }
+     * ```
+     */
+    listAutoPaginate(params?: Omit<UnusualTradeListParams, 'offset'>, options?: AutoPaginateOptions): AsyncGenerator<UnusualTrade, void, undefined>;
+}
+
+/**
+ * A historical market snapshot.
+ */
+interface MarketHistoryEntry {
+    /** Market ID */
+    marketId: string;
+    /** Snapshot date (YYYY-MM-DD) */
+    snapshotDate: string;
+    /** Snapshot data (market state at that time) */
+    [key: string]: unknown;
+}
+/**
+ * Parameters for listing market history.
+ */
+interface HistoryListParams {
+    /** Filter by specific market ID */
+    marketId?: string;
+    /** Filter by source platform */
+    source?: MarketSource;
+    /** Filter by category */
+    category?: MarketCategory;
+    /** Number of days of history (default: 30) */
+    days?: number;
+    /** Maximum results (default: 1000) */
+    limit?: number;
+}
+/**
+ * A date with available snapshot data.
+ */
+interface SnapshotDate {
+    /** Date string (YYYY-MM-DD) */
+    date: string;
+    /** Number of markets captured */
+    count: number;
+}
+
+declare class History {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List historical market snapshots.
+     * Requires Business plan or higher.
+     *
+     * @example
+     * ```ts
+     * const { data: history } = await client.history.list({ marketId: 'pm_12345', days: 7 });
+     * ```
+     */
+    list(params?: HistoryListParams): Promise<APIResponse<MarketHistoryEntry[]>>;
+    /**
+     * List available snapshot dates.
+     * Requires Business plan or higher.
+     *
+     * @example
+     * ```ts
+     * const { data: dates } = await client.history.dates();
+     * console.log(dates); // [{ date: '2025-02-01', count: 150 }, ...]
+     * ```
+     */
+    dates(): Promise<APIResponse<SnapshotDate[]>>;
+}
+
+/**
+ * API key usage statistics.
+ */
+interface KeyUsage {
+    /** Requests made today */
+    daily: number;
+    /** Requests made this minute */
+    minute: number;
+    /** Total requests ever */
+    total: number;
+}
+/**
+ * Daily usage history entry.
+ */
+interface UsageHistoryEntry {
+    /** Date (YYYY-MM-DD) */
+    date: string;
+    /** Number of requests */
+    count: number;
+}
+/**
+ * Plan rate limits.
+ */
+interface PlanLimits {
+    /** Maximum requests per day */
+    requestsPerDay: number;
+    /** Maximum requests per minute */
+    requestsPerMinute: number;
+}
+/**
+ * Information about the current API key.
+ */
+interface KeyInfo {
+    /** Key ID */
+    id: string;
+    /** Key name */
+    name: string;
+    /** Plan name */
+    plan: string;
+    /** Rate limits for the plan */
+    limits: PlanLimits;
+    /** Current usage */
+    usage: KeyUsage;
+    /** Daily usage history */
+    history: UsageHistoryEntry[];
+    /** When the key was created (ISO 8601) */
+    createdAt: string;
+    /** When the key was last used (ISO 8601, may be null) */
+    lastUsedAt: string | null;
+}
+
+declare class Keys {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * Get information about the current API key, including usage statistics.
+     *
+     * @example
+     * ```ts
+     * const { data: keyInfo } = await client.keys.me();
+     * console.log(`Plan: ${keyInfo.plan}`);
+     * console.log(`Daily usage: ${keyInfo.usage.daily}/${keyInfo.limits.requestsPerDay}`);
+     * ```
+     */
+    me(): Promise<APIResponse<KeyInfo>>;
+}
+
+/**
+ * A simplified market item for the ticker.
+ */
+interface TickerItem {
+    /** Market ID */
+    id: string;
+    /** Market question */
+    question: string;
+    /** Primary outcome probability */
+    probability: number;
+    /** Source platform */
+    source: MarketSource;
+}
+/**
+ * Parameters for listing ticker items.
+ */
+interface TickerListParams {
+    /** Maximum items (default: 12, max: 20) */
+    limit?: number;
+}
+
+declare class Ticker {
+    private client;
+    constructor(client: BaseClient);
+    /**
+     * List ticker items (public, no auth required).
+     *
+     * @example
+     * ```ts
+     * const { data: items } = await client.ticker.list({ limit: 10 });
+     * for (const item of items) {
+     *   console.log(`${item.question}: ${(item.probability * 100).toFixed(0)}%`);
+     * }
+     * ```
+     */
+    list(params?: TickerListParams): Promise<APIResponse<TickerItem[]>>;
+}
+
+/**
+ * Propheseer SDK client for the prediction markets API.
+ *
+ * @example
+ * ```ts
+ * import Propheseer from 'propheseer';
+ *
+ * const client = new Propheseer({ apiKey: 'pk_test_...' });
+ *
+ * // List markets
+ * const page = await client.markets.list({ source: 'polymarket' });
+ * console.log(page.data);
+ *
+ * // Find arbitrage (Pro+)
+ * const { data: opportunities } = await client.arbitrage.find();
+ *
+ * // Check your usage
+ * const { data: keyInfo } = await client.keys.me();
+ * ```
+ */
+declare class Propheseer extends BaseClient {
+    /** List and search prediction markets */
+    readonly markets: Markets;
+    /** List market categories */
+    readonly categories: Categories;
+    /** Find cross-platform arbitrage opportunities (Pro+) */
+    readonly arbitrage: Arbitrage;
+    /** Detect unusual trading activity (Pro+) */
+    readonly unusualTrades: UnusualTrades;
+    /** Access historical market snapshots (Business+) */
+    readonly history: History;
+    /** Get API key info and usage statistics */
+    readonly keys: Keys;
+    /** Public market ticker (no auth required) */
+    readonly ticker: Ticker;
+    constructor(options?: ClientOptions);
+}
+
+/**
+ * WebSocket message types received from the server.
+ */
+interface WSConnectedMessage {
+    type: 'connected';
+    sessionId: string;
+    plan: string;
+    limits: {
+        maxSubscriptions: number;
+        messagesPerMinute: number;
+        maxConnections: number;
+        monthlyDataMB: number;
+    };
+}
+interface WSMarketUpdateMessage {
+    type: 'market_update';
+    market: Record<string, unknown>;
+    timestamp: string;
+}
+interface WSMarketSnapshotMessage {
+    type: 'market_snapshot';
+    market: Record<string, unknown>;
+    timestamp: string;
+}
+interface WSSubscribedMessage {
+    type: 'subscribed';
+    markets: string[];
+    alreadySubscribed: string[];
+    notFound: string[];
+    subscriptionCount: number;
+}
+interface WSUnsubscribedMessage {
+    type: 'unsubscribed';
+    markets: string[];
+    notSubscribed: string[];
+    subscriptionCount: number;
+}
+interface WSSubscriptionsMessage {
+    type: 'subscriptions';
+    markets: string[];
+    count: number;
+}
+interface WSPongMessage {
+    type: 'pong';
+    timestamp: string;
+}
+interface WSErrorMessage {
+    type: 'error';
+    code: string;
+    message: string;
+}
+type WSMessage = WSConnectedMessage | WSMarketUpdateMessage | WSMarketSnapshotMessage | WSSubscribedMessage | WSUnsubscribedMessage | WSSubscriptionsMessage | WSPongMessage | WSErrorMessage;
+interface PropheseerWebSocketOptions {
+    /** API key for authentication */
+    apiKey?: string;
+    /** Base WebSocket URL (default: wss://api.propheseer.com) */
+    baseURL?: string;
+    /** Whether to automatically reconnect on disconnect (default: true) */
+    reconnect?: boolean;
+    /** Maximum reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Ping interval in ms to keep connection alive (default: 25000) */
+    pingInterval?: number;
+}
+interface PropheseerWebSocketEvents {
+    connected: (message: WSConnectedMessage) => void;
+    market_update: (message: WSMarketUpdateMessage) => void;
+    market_snapshot: (message: WSMarketSnapshotMessage) => void;
+    subscribed: (message: WSSubscribedMessage) => void;
+    unsubscribed: (message: WSUnsubscribedMessage) => void;
+    error: (error: WSErrorMessage | Error) => void;
+    disconnect: (code: number, reason: string) => void;
+    reconnect: (attempt: number) => void;
+}
+/**
+ * WebSocket client for real-time market updates.
+ *
+ * @example
+ * ```ts
+ * const ws = new PropheseerWebSocket({ apiKey: 'pk_test_...' });
+ *
+ * ws.on('connected', (msg) => {
+ *   console.log('Connected:', msg.sessionId);
+ *   ws.subscribe(['pm_12345', 'ks_67890']);
+ * });
+ *
+ * ws.on('market_update', (msg) => {
+ *   console.log('Update:', msg.market);
+ * });
+ *
+ * await ws.connect();
+ * ```
+ */
+declare class PropheseerWebSocket extends EventEmitter {
+    private apiKey;
+    private baseURL;
+    private reconnectEnabled;
+    private maxReconnectAttempts;
+    private pingIntervalMs;
+    private ws;
+    private pingTimer;
+    private reconnectAttempts;
+    private subscribedMarkets;
+    private closed;
+    constructor(options?: PropheseerWebSocketOptions);
+    /**
+     * Connect to the WebSocket server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Subscribe to real-time updates for specific market IDs.
+     */
+    subscribe(marketIds: string[]): void;
+    /**
+     * Unsubscribe from market updates.
+     */
+    unsubscribe(marketIds: string[]): void;
+    /**
+     * Request the current list of subscribed markets.
+     */
+    listSubscriptions(): void;
+    /**
+     * Close the WebSocket connection.
+     */
+    close(): void;
+    private handleMessage;
+    private send;
+    private getReadyState;
+    private startPing;
+    private stopPing;
+    private attemptReconnect;
+    private getWebSocketConstructor;
+}
+
+declare const VERSION = "0.1.0";
+
+/**
+ * Base error class for all Propheseer SDK errors.
+ */
+declare class PropheseerError extends Error {
+    /** HTTP status code (if applicable) */
+    readonly status: number | undefined;
+    /** Error code from the API */
+    readonly code: string | undefined;
+    /** Response headers */
+    readonly headers: Headers | undefined;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        headers?: Headers;
+    });
+}
+/**
+ * Thrown when the API key is missing or invalid (HTTP 401).
+ */
+declare class AuthenticationError extends PropheseerError {
+    constructor(message: string, headers?: Headers);
+}
+/**
+ * Thrown when the user has insufficient credits (HTTP 402).
+ */
+declare class InsufficientCreditsError extends PropheseerError {
+    /** Current balance in cents */
+    readonly balanceCents: number | undefined;
+    /** Required amount in cents */
+    readonly requiredCents: number | undefined;
+    constructor(message: string, options?: {
+        balanceCents?: number;
+        requiredCents?: number;
+        headers?: Headers;
+    });
+}
+/**
+ * Thrown when the user lacks permission for the requested resource (HTTP 403).
+ */
+declare class PermissionDeniedError extends PropheseerError {
+    /** Plan required to access the resource */
+    readonly requiredPlan: string | undefined;
+    constructor(message: string, options?: {
+        code?: string;
+        requiredPlan?: string;
+        headers?: Headers;
+    });
+}
+/**
+ * Thrown when the requested resource is not found (HTTP 404).
+ */
+declare class NotFoundError extends PropheseerError {
+    constructor(message: string, headers?: Headers);
+}
+/**
+ * Thrown when rate limits are exceeded (HTTP 429).
+ */
+declare class RateLimitError extends PropheseerError {
+    /** Seconds to wait before retrying */
+    readonly retryAfter: number | undefined;
+    constructor(message: string, options?: {
+        retryAfter?: number;
+        headers?: Headers;
+    });
+}
+/**
+ * Thrown when the API returns a server error (HTTP 5xx).
+ */
+declare class InternalServerError extends PropheseerError {
+    constructor(message: string, options?: {
+        status?: number;
+        headers?: Headers;
+    });
+}
+/**
+ * Thrown when a network or connection error occurs.
+ */
+declare class APIConnectionError extends PropheseerError {
+    readonly cause: Error | undefined;
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+
+export { APIConnectionError, type APIResponse, type ArbitrageFindParams, type ArbitrageMarket, type ArbitrageOpportunity, AuthenticationError, type AutoPaginateOptions, type Category, type ClientOptions, type DetectionInfo, type DetectionReason, type HistoryListParams, InsufficientCreditsError, InternalServerError, type KeyInfo, type KeyUsage, type Market, type MarketCategory, type MarketHistoryEntry, type MarketListParams, type MarketSource, type MarketStatus, NotFoundError, type Outcome, Page, type PaginationMeta, PermissionDeniedError, type PlanLimits, Propheseer, PropheseerError, PropheseerWebSocket, type PropheseerWebSocketEvents, type PropheseerWebSocketOptions, RateLimitError, type RateLimitInfo, type SnapshotDate, type TickerItem, type TickerListParams, type TradeDetails, type TradeSide, type UnusualTrade, type UnusualTradeListParams, type UnusualTradeMarket, type UsageHistoryEntry, VERSION, type WSConnectedMessage, type WSErrorMessage, type WSMarketSnapshotMessage, type WSMarketUpdateMessage, type WSMessage, type WSSubscribedMessage, type WSUnsubscribedMessage, autoPaginate, Propheseer as default };