@dealcrawl/sdk 2.10.0 → 2.11.1

package/dist/index.d.mts

@@ -19,7 +19,7 @@ interface ResponseMeta {
     timestamp: string;
     duration?: number;
 }
-type JobStatus = "pending" | "active" | "completed" | "failed" | "delayed" | "paused";
+type JobStatus$1 = "pending" | "active" | "completed" | "failed" | "delayed" | "paused";
 interface PaginatedResponse<T> {
     data: T[];
     pagination: {
@@ -130,10 +130,19 @@ interface DealScoreSummary {
     };
 }
 interface ScreenshotResult {
+    /** Screenshot URL - private signed URL (default) or public URL (Enterprise opt-in) */
     url: string;
+    /** Whether this is a public URL (false = private signed URL with TTL) */
+    isPublic: boolean;
+    /** Expiration timestamp for signed URLs (ISO 8601, only for private URLs) */
+    expiresAt?: string;
+    /** Screenshot width in pixels */
     width: number;
+    /** Screenshot height in pixels */
     height: number;
+    /** Image format */
     format: "png" | "jpeg" | "webp";
+    /** File size in bytes */
     sizeBytes: number;
 }
 interface AIExtraction {
@@ -438,7 +447,7 @@ interface JobResponse {
     /** Unique job identifier */
     jobId: string;
     /** Current job status */
-    status: JobStatus;
+    status: JobStatus$1;
     /** URL to check job status */
     statusUrl: string;
     /** Estimated time to completion */
@@ -468,6 +477,15 @@ interface BatchScrapeResultItem {
     /** Error message if job creation failed */
     error?: string;
 }
+/** Invalid URL entry (returned when ignoreInvalidURLs=true) */
+interface InvalidURLEntry {
+    /** The invalid URL */
+    url: string;
+    /** Reference ID if provided */
+    ref?: string;
+    /** Reason for rejection */
+    reason: string;
+}
 /** Batch scrape response */
 interface BatchScrapeResponse {
     /** Batch ID for tracking */
@@ -482,6 +500,11 @@ interface BatchScrapeResponse {
     results: BatchScrapeResultItem[];
     /** Timestamp when batch was created */
     createdAt: string;
+    /**
+     * Invalid URLs that were skipped (only present when ignoreInvalidURLs=true)
+     * Firecrawl-compatible field
+     */
+    invalidURLs?: InvalidURLEntry[];
 }
 /** Batch status response */
 interface BatchStatusResponse {
@@ -502,7 +525,7 @@ interface BatchStatusResponse {
     /** Individual job statuses */
     jobs: Array<{
         id: string;
-        status: JobStatus;
+        status: JobStatus$1;
         result?: unknown;
         error?: string;
     }>;
@@ -612,7 +635,7 @@ interface CheckpointInfo {
 /** Job status response */
 interface JobStatusResponse {
     jobId: string;
-    status: JobStatus;
+    status: JobStatus$1;
     progress?: number;
     createdAt: string;
     completedAt?: string;
@@ -652,7 +675,7 @@ interface ResumeJobResponse {
 /** Job metrics response */
 interface JobMetricsResponse {
     jobId: string;
-    status: JobStatus;
+    status: JobStatus$1;
     metrics: {
         totalUrls: number;
         successfulUrls: number;
@@ -671,7 +694,7 @@ interface CancelJobResponse {
 interface JobSummary {
     id: string;
     type: "scrape" | "crawl" | "dork" | "extract";
-    status: JobStatus;
+    status: JobStatus$1;
     input: Record<string, unknown>;
     dealsFound?: number;
     avgDealScore?: number;
@@ -769,10 +792,17 @@ interface CreateWebhookResponse {
     minDealScore: number;
     active: boolean;
 }
-/** List webhooks response */
+/** List webhooks response (standardized list format) */
 interface ListWebhooksResponse {
-    webhooks: WebhookItem[];
-    count: number;
+    data: WebhookItem[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasMore: boolean;
+    };
+    meta?: Record<string, unknown>;
 }
 /** Update webhook response */
 interface UpdateWebhookResponse {
@@ -964,7 +994,7 @@ interface AgentStepResponse {
     currentUrl?: string;
 }
 /** Agent completion reason */
-type AgentCompletionReason = "goal_achieved" | "max_steps_reached" | "stuck" | "error" | "cancelled";
+type AgentCompletionReason = "goal_achieved" | "max_steps_reached" | "stuck" | "error";
 /** Agent result (from completed job) */
 interface AgentResultResponse {
     /** Extracted/collected data (matches provided schema if given) */
@@ -1013,6 +1043,113 @@ interface SchemaGenerationResponse {
     /** Confidence score (0-1) in the generated schema */
     confidence: number;
 }
+/** SSE token response */
+interface SSETokenResponse {
+    /** Short-lived SSE authentication token */
+    token: string;
+    /** Expiration timestamp (ISO 8601) */
+    expiresAt: string;
+    /** TTL in seconds (default: 300 = 5 minutes) */
+    expiresIn: number;
+    /** Token type identifier */
+    type: "sse_token";
+    /** Usage instructions for the token */
+    usage: string;
+}
+/** SSE connection limits response */
+interface SSEConnectionLimitsResponse {
+    /** Client tier */
+    tier: "free" | "pro" | "enterprise";
+    /** SSE connection limits */
+    sse: {
+        /** Maximum concurrent connections allowed */
+        maxConnections: number;
+        /** Current active connections */
+        currentConnections: number;
+        /** Available connection slots */
+        available: number;
+    };
+}
+/** Tier-specific TTL limits */
+interface TtlLimits {
+    /** Minimum TTL in seconds */
+    min: number;
+    /** Maximum TTL in seconds */
+    max: number;
+    /** Default TTL in seconds */
+    default: number;
+}
+/** Formatted TTL limits (human-readable) */
+interface FormattedTtlLimits {
+    /** Minimum TTL formatted (e.g., "1 hour") */
+    min: string;
+    /** Maximum TTL formatted (e.g., "30 days") */
+    max: string;
+    /** Default TTL formatted (e.g., "7 days") */
+    default: string;
+}
+/** Screenshot signed URL refresh response */
+interface ScreenshotRefreshResponse {
+    /** Success status */
+    success: boolean;
+    /** New signed URL */
+    url: string;
+    /** Expiration timestamp (ISO 8601) */
+    expiresAt: string;
+    /** TTL in seconds */
+    ttl: number;
+    /** Tier-specific limits for reference */
+    tierLimits: TtlLimits;
+    /** Additional metadata */
+    metadata: {
+        /** File path in storage */
+        path: string;
+        /** Bucket name */
+        bucket: string;
+        /** Timestamp when URL was refreshed */
+        refreshedAt: string;
+    };
+}
+/** Screenshot TTL limits response */
+interface ScreenshotLimitsResponse {
+    /** Client tier */
+    tier: "free" | "pro" | "enterprise";
+    /** TTL limits in seconds */
+    limits: TtlLimits;
+    /** Human-readable formatted limits */
+    formattedLimits: FormattedTtlLimits;
+}
+/**
+ * Metadata extracted during HTML to Markdown conversion
+ */
+interface ConversionMetadata {
+    /** Page title if found */
+    title?: string;
+    /** Word count in resulting markdown */
+    wordCount: number;
+    /** Number of links in markdown */
+    linkCount: number;
+    /** Number of images in markdown */
+    imageCount: number;
+    /** Conversion duration in milliseconds */
+    conversionTimeMs: number;
+}
+/**
+ * HTML to Markdown conversion response
+ */
+interface ConvertResponse {
+    /** Success status */
+    success: boolean;
+    /** Conversion result data */
+    data: {
+        /** Generated markdown content */
+        markdown: string;
+        /** Extraction metadata */
+        metadata: ConversionMetadata;
+        /** Warnings (truncation, excluded elements, etc.) */
+        warnings?: string[];
+    };
+}
 
 /**
  * Polling Utilities
@@ -1092,10 +1229,19 @@ interface ScreenshotOptions {
     /**
      * Request public URL (Enterprise only, default: false)
      * SECURITY WARNING: Public URLs can expose personal data, copyrighted content, and tokens
-     * By default, screenshots use private signed URLs with 7-day expiration
+     * By default, screenshots use private signed URLs with tier-specific expiration
      * Requires Enterprise tier
      */
     publicUrl?: boolean;
+    /**
+     * TTL for signed URLs in seconds (only for private screenshots)
+     * Tier limits:
+     * - Free: 3600 (1h) - 86400 (24h), default: 86400
+     * - Pro: 3600 (1h) - 604800 (7d), default: 604800
+     * - Enterprise: 3600 (1h) - 2592000 (30d), default: 604800
+     * If not specified, uses tier-specific default
+     */
+    signedUrlTtl?: number;
 }
 /** Options for scraping a single page */
 interface ScrapeOptions {
@@ -1158,8 +1304,6 @@ interface BatchScrapeItem {
     outputMarkdown?: boolean;
     /** Override markdownBaseUrl for this URL */
     markdownBaseUrl?: string;
-    /** Override actions for this URL */
-    actions?: ActionInput[];
 }
 /** Default options applied to all URLs in a batch */
 interface BatchScrapeDefaults {
@@ -1195,8 +1339,6 @@ interface BatchScrapeDefaults {
     outputMarkdown?: boolean;
     /** Base URL for resolving relative URLs in markdown */
     markdownBaseUrl?: string;
-    /** Browser actions to execute before scraping */
-    actions?: ActionInput[];
 }
 /** Options for batch scraping multiple URLs */
 interface BatchScrapeOptions {
@@ -1208,8 +1350,13 @@ interface BatchScrapeOptions {
     webhookUrl?: string;
     /** Priority for batch jobs (1-10, higher = faster) */
     priority?: number;
-    /** Delay between job submissions in ms (0-5000) */
-    delay?: number;
+    /** Delay between job submissions in ms (0-5000, default: 0) */
+    delayMs?: number;
+    /**
+     * Continue processing even if some URLs are invalid (default: false)
+     * Invalid URLs will be returned in the response with status: "failed"
+     */
+    ignoreInvalidURLs?: boolean;
 }
 /** AI provider for search optimization */
 type SearchAiProvider = "openai" | "anthropic";
@@ -1237,11 +1384,11 @@ interface SearchOptions {
     /** Search query (required) */
     query: string;
     /** Maximum number of results (1-100, default: 10) */
-    maxResults?: number;
-    /** Auto-scrape top results */
-    autoScrape?: boolean;
-    /** Number of results to auto-scrape (1-10, default: 5) */
-    autoScrapeLimit?: number;
+    limit?: number;
+    /** Auto-scrape search results (default: false) */
+    scrapeResults?: boolean;
+    /** Maximum results to auto-scrape when scrapeResults=true (1-10, default: 5) */
+    maxScrapeResults?: number;
     /** Use AI to optimize the search query */
     useAiOptimization?: boolean;
     /** AI provider for query optimization */
@@ -1275,7 +1422,7 @@ interface PriceRange {
 interface CrawlOptions {
     /** Starting URL for the crawl (required) */
     url: string;
-    /** Alias for url - Starting URL for the crawl */
+    /** @deprecated Use 'url' instead. Kept for backward compatibility. */
     startUrl?: string;
     /** Prompt to guide the crawl (optional) */
     prompt?: string;
@@ -1352,7 +1499,7 @@ interface CrawlTemplate {
     defaultOptions: Partial<CrawlOptions>;
 }
 /** LLM model options for extraction */
-type ExtractModel = "gpt-4o-mini" | "gpt-4o" | "claude-3-haiku" | "claude-3-sonnet";
+type ExtractModel = "gpt-4o-mini" | "gpt-4o" | "gpt-4o-2024-11-20" | "o1-mini" | "claude-3-5-haiku-20241022" | "claude-3-5-sonnet-20241022" | "claude-3-opus-20240229";
 /** Options for structured data extraction */
 interface ExtractOptions {
     /** URL to extract data from (required) */
@@ -1395,8 +1542,6 @@ interface DorkOptions {
     inTitle?: string;
     /** Maximum results to return (default: 10, max: 100) */
     maxResults?: number;
-    /** Region code (2 letter ISO code) */
-    region?: string;
 }
 /** Options for getting job deals */
 interface GetDealsOptions {
@@ -1472,19 +1617,25 @@ interface ExportDealsOptions {
     format?: ExportFormat;
     /** Minimum deal score */
     minScore?: number;
-    /** Maximum price */
-    maxPrice?: number;
     /** Filter by category */
     category?: string;
-    /** Include raw signals in export */
-    includeRawSignals?: boolean;
+    /** Filter by sync status to DealUp */
+    synced?: boolean;
+    /** Filter from date (ISO string) */
+    fromDate?: string;
+    /** Filter to date (ISO string) */
+    toDate?: string;
+    /** Maximum number of deals to export (default: 500, max: 1000) */
+    limit?: number;
 }
 /** Webhook event types */
 type WebhookEvent = "deal.found" | "deal.synced" | "crawl.completed" | "crawl.failed";
 /** Options for creating a webhook */
 interface CreateWebhookOptions {
-    /** Event type to subscribe to */
-    event: WebhookEvent;
+    /** Event types to subscribe to (array) */
+    events?: WebhookEvent[];
+    /** @deprecated Use 'events' array instead */
+    event?: WebhookEvent;
     /** URL to receive webhook notifications */
     url: string;
     /** Secret for signature verification */
@@ -1513,7 +1664,7 @@ interface UpdateWebhookOptions {
  * API key scope - Must match @dealcrawl/shared/src/types/api-key.types.ts
  * These are the actual scopes enforced by the backend via requireScope() middleware
  */
-type ApiKeyScope = "scrape" | "scrape:batch" | "search" | "crawl" | "dork" | "extract" | "agent" | "status" | "data:read" | "data:export" | "keys:manage" | "webhooks:manage";
+type ApiKeyScope = "scrape" | "crawl" | "dork" | "extract" | "agent" | "status" | "data:read" | "data:export" | "keys:manage" | "webhooks:manage";
 /**
  * All available scopes (for reference and validation)
  */
@@ -1691,6 +1842,71 @@ interface SchemaGenerationOptions {
     /** LLM provider for generation (default: openai) */
     model?: AgentModel;
 }
+/**
+ * Options for subscribing to SSE events
+ */
+interface SSESubscribeOptions {
+    /**
+     * Last event ID for reconnection/replay
+     * If provided, server will replay missed events since this ID
+     */
+    lastEventId?: string;
+    /**
+     * Callback for received events
+     * Called for each event received from the server
+     */
+    onEvent?: (event: MessageEvent) => void;
+    /**
+     * Callback for errors
+     * Called when connection error occurs
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback for connection open
+     * Called when SSE connection is established
+     */
+    onOpen?: (event: Event) => void;
+    /**
+     * Auto-reconnect on connection loss (default: true)
+     * If true, EventSource will automatically reconnect
+     */
+    autoReconnect?: boolean;
+    /**
+     * Reconnection delay in milliseconds (default: 3000)
+     * How long to wait before attempting reconnection
+     */
+    reconnectDelay?: number;
+}
+/**
+ * Options for HTML to Markdown conversion
+ */
+interface ConvertOptions {
+    /** HTML content to convert (required, max 10MB) */
+    html: string;
+    /** Base URL for resolving relative URLs */
+    baseUrl?: string;
+    /** Conversion options */
+    options?: {
+        /** Enable GFM tables (default: true) */
+        gfmTables?: boolean;
+        /** Enable GFM strikethrough (default: true) */
+        gfmStrikethrough?: boolean;
+        /** Enable GFM task lists (default: true) */
+        gfmTaskLists?: boolean;
+        /** Remove noise elements like nav, footer, ads (default: true) */
+        removeNoise?: boolean;
+        /** CSS selectors to exclude from conversion */
+        excludeSelectors?: string[];
+        /** Resolve relative URLs to absolute (default: true) */
+        absoluteUrls?: boolean;
+        /** Maximum output length in characters (0 = unlimited, max: 1,000,000) */
+        maxLength?: number;
+        /** Include images in output (default: true) */
+        includeImages?: boolean;
+        /** Include links in output (default: true) */
+        includeLinks?: boolean;
+    };
+}
 
 /**
  * Account Resource
@@ -2035,6 +2251,257 @@ declare class AgentResource {
     generateSchema(options: SchemaGenerationOptions): Promise<SchemaGenerationResponse>;
 }
 
+/**
+ * Auth Resource
+ * Handles SSE (Server-Sent Events) authentication
+ */
+
+/**
+ * Options for generating an SSE token
+ */
+interface GenerateSSETokenOptions {
+    /**
+     * Optional job ID to restrict token to a specific job
+     * If provided, token can only be used for /v1/events/:jobId
+     * If omitted, token can be used for /v1/events (all events)
+     */
+    jobId?: string;
+}
+/**
+ * Auth resource class
+ * Provides methods for SSE authentication
+ *
+ * @example
+ * ```ts
+ * // Generate SSE token for browser EventSource
+ * const { token, expiresAt } = await client.auth.generateSSEToken();
+ *
+ * // Use in browser
+ * const eventSource = new EventSource(`/v1/events?token=${token}`);
+ *
+ * // Token for specific job
+ * const jobToken = await client.auth.generateSSEToken({ jobId: "job_123" });
+ * const jobEvents = new EventSource(`/v1/events/job_123?token=${jobToken.token}`);
+ * ```
+ */
+declare class AuthResource {
+    private ctx;
+    constructor(ctx: RequestContext);
+    /**
+     * Generate SSE authentication token
+     *
+     * Required for browser-based SSE connections because EventSource API
+     * doesn't support custom headers. Token is short-lived (5 minutes).
+     *
+     * Security:
+     * - Requires valid API key (Bearer token)
+     * - Token expires in 5 minutes
+     * - Token can be restricted to specific job
+     * - Token stored in Redis (revocable)
+     *
+     * @example
+     * ```ts
+     * // 1. Generate token
+     * const { token, expiresAt } = await client.auth.generateSSEToken();
+     * console.log(`Token expires at: ${expiresAt}`);
+     *
+     * // 2. Use in browser EventSource
+     * const eventSource = new EventSource(`/v1/events?token=${token}`);
+     *
+     * eventSource.addEventListener('job.completed', (event) => {
+     *   const data = JSON.parse(event.data);
+     *   console.log('Job completed:', data);
+     * });
+     *
+     * // 3. For specific job only
+     * const jobToken = await client.auth.generateSSEToken({ jobId: "job_abc123" });
+     * const jobEvents = new EventSource(`/v1/events/job_abc123?token=${jobToken.token}`);
+     * ```
+     */
+    generateSSEToken(options?: GenerateSSETokenOptions): Promise<SSETokenResponse>;
+    /**
+     * Get SSE connection limits for current tier
+     *
+     * Shows how many concurrent SSE connections are allowed
+     * and how many are currently active.
+     *
+     * Tier limits:
+     * - Free: 10 concurrent connections
+     * - Pro: 50 concurrent connections
+     * - Enterprise: 200 concurrent connections
+     *
+     * @example
+     * ```ts
+     * const limits = await client.auth.getLimits();
+     *
+     * console.log(`Tier: ${limits.tier}`);
+     * console.log(`Max connections: ${limits.sse.maxConnections}`);
+     * console.log(`Current connections: ${limits.sse.currentConnections}`);
+     * console.log(`Available: ${limits.sse.available}`);
+     *
+     * // Check before opening new connection
+     * if (limits.sse.available > 0) {
+     *   const token = await client.auth.generateSSEToken();
+     *   const eventSource = new EventSource(`/v1/events?token=${token.token}`);
+     * } else {
+     *   console.error('No available SSE connection slots');
+     * }
+     * ```
+     */
+    getLimits(): Promise<SSEConnectionLimitsResponse>;
+}
+
+/**
+ * Convert Resource
+ * Handles HTML to Markdown conversion
+ */
+
+/**
+ * Convert resource class
+ * Provides methods for HTML to Markdown conversion
+ *
+ * @example
+ * ```ts
+ * // Convert HTML to markdown
+ * const result = await client.convert.htmlToMarkdown({
+ *   html: "<h1>Title</h1><p>Content</p>",
+ *   baseUrl: "https://example.com",
+ *   options: {
+ *     gfmTables: true,
+ *     removeNoise: true
+ *   }
+ * });
+ *
+ * console.log(result.data.markdown);
+ * console.log(result.data.metadata.wordCount);
+ * ```
+ */
+declare class ConvertResource {
+    private ctx;
+    constructor(ctx: RequestContext);
+    /**
+     * Convert HTML to Markdown
+     *
+     * Transforms raw HTML content into clean, readable Markdown using GitHub Flavored Markdown (GFM).
+     * Useful for:
+     * - Converting scraped HTML to markdown for LLM processing
+     * - Cleaning up messy HTML from web pages
+     * - Extracting main content while removing noise (ads, nav, footer)
+     * - Creating documentation from HTML sources
+     *
+     * Features:
+     * - GFM table, strikethrough, and task list support
+     * - Automatic noise removal (scripts, ads, navigation)
+     * - Relative URL resolution
+     * - Custom element exclusion via CSS selectors
+     * - Output length limiting
+     *
+     * @param options - Conversion options
+     * @returns Conversion result with markdown, metadata, and warnings
+     *
+     * @example Basic usage
+     * ```ts
+     * const result = await client.convert.htmlToMarkdown({
+     *   html: "<h1>Product</h1><p>Price: $99</p>"
+     * });
+     * console.log(result.data.markdown);
+     * ```
+     *
+     * @example With all options
+     * ```ts
+     * const result = await client.convert.htmlToMarkdown({
+     *   html: htmlContent,
+     *   baseUrl: "https://shop.example.com",
+     *   options: {
+     *     gfmTables: true,
+     *     removeNoise: true,
+     *     excludeSelectors: [".advertisement", "#sidebar"],
+     *     absoluteUrls: true,
+     *     maxLength: 100000,
+     *     includeImages: true,
+     *     includeLinks: true
+     *   }
+     * });
+     *
+     * // Check metadata
+     * console.log(`Words: ${result.data.metadata.wordCount}`);
+     * console.log(`Links: ${result.data.metadata.linkCount}`);
+     * console.log(`Images: ${result.data.metadata.imageCount}`);
+     * console.log(`Conversion time: ${result.data.metadata.conversionTimeMs}ms`);
+     *
+     * // Check for warnings
+     * if (result.data.warnings?.length) {
+     *   console.warn("Conversion warnings:", result.data.warnings);
+     * }
+     * ```
+     *
+     * @example Converting scraped HTML
+     * ```ts
+     * // First scrape a page
+     * const scrapeJob = await client.scrape.create({
+     *   url: "https://example.com/article"
+     * });
+     * const scrapeResult = await client.waitForResult(scrapeJob.jobId);
+     *
+     * // Then convert HTML to markdown
+     * const markdown = await client.convert.htmlToMarkdown({
+     *   html: scrapeResult.data.html,
+     *   baseUrl: scrapeResult.data.url,
+     *   options: {
+     *     removeNoise: true,
+     *     onlyMainContent: true
+     *   }
+     * });
+     * ```
+     */
+    htmlToMarkdown(options: ConvertOptions): Promise<ConvertResponse>;
+    /**
+     * Alias for htmlToMarkdown() for convenience
+     *
+     * @example
+     * ```ts
+     * const result = await client.convert.toMarkdown({
+     *   html: "<h1>Hello</h1>"
+     * });
+     * ```
+     */
+    toMarkdown(options: ConvertOptions): Promise<ConvertResponse>;
+    /**
+     * Convert HTML with minimal options (just the HTML content)
+     * Uses all default settings
+     *
+     * @param html - HTML content to convert
+     * @param baseUrl - Optional base URL for resolving relative links
+     * @returns Conversion result
+     *
+     * @example
+     * ```ts
+     * const result = await client.convert.quick(
+     *   "<h1>Title</h1><p>Content</p>",
+     *   "https://example.com"
+     * );
+     * console.log(result.data.markdown);
+     * ```
+     */
+    quick(html: string, baseUrl?: string): Promise<ConvertResponse>;
+    /**
+     * Convert HTML with noise removal enabled
+     * Removes navigation, footer, ads, scripts, and other clutter
+     *
+     * @param html - HTML content to convert
+     * @param baseUrl - Optional base URL
+     * @returns Conversion result with clean markdown
+     *
+     * @example
+     * ```ts
+     * // Extract just the main content from a messy page
+     * const result = await client.convert.clean(messyHtml, "https://example.com");
+     * console.log(result.data.markdown); // Clean, readable markdown
+     * ```
+     */
+    clean(html: string, baseUrl?: string): Promise<ConvertResponse>;
+}
+
 /**
  * Crawl Resource
  * Handles website crawling operations
@@ -2220,17 +2687,9 @@ declare class DataResource {
      * @example
      * ```ts
      * const electronicsDeals = await client.data.getDealsByCategory("electronics");
-    async getDealsByCategory(
-      category: string,
-      options?: Omit<ListDealsOptions, "category">
-    ): Promise<ListDealsResponse> {
-      if (!category || !category.trim()) {
-        throw new Error("category is required and cannot be empty");
-      }
-      return this.listDeals({ category, ...options });
-    }    return this.listDeals({ category, ...options });
-    }
-  
+     * ```
+     */
+    getDealsByCategory(category: string, options?: Omit<ListDealsOptions, "category">): Promise<ListDealsResponse>;
     /**
      * Get unsynced deals (not yet sent to DealUp)
      *
@@ -2385,6 +2844,177 @@ declare class DorkResource {
     buildQuery(options: DorkOptions): string;
 }
 
+/**
+ * Events Resource
+ * Handles real-time SSE (Server-Sent Events) streaming
+ */
+
+/**
+ * Events resource class
+ * Provides methods for subscribing to real-time job events via SSE
+ *
+ * IMPORTANT: Browser Support Only
+ * This resource uses the EventSource API which is only available in browsers.
+ * For Node.js, use polling via client.status.get() instead.
+ *
+ * @example Browser Usage
+ * ```ts
+ * // 1. Generate SSE token (required for EventSource)
+ * const { token } = await client.auth.generateSSEToken();
+ *
+ * // 2. Subscribe to all events
+ * const eventSource = client.events.subscribe({
+ *   token,
+ *   onEvent: (event) => {
+ *     console.log('Event:', event.type, event.data);
+ *   }
+ * });
+ *
+ * // 3. Or subscribe to specific job
+ * const jobEvents = client.events.subscribeToJob('job_123', {
+ *   token,
+ *   onEvent: (event) => {
+ *     const data = JSON.parse(event.data);
+ *     console.log('Job event:', data);
+ *   }
+ * });
+ *
+ * // 4. Clean up when done
+ * eventSource.close();
+ * ```
+ */
+declare class EventsResource {
+    private ctx;
+    constructor(ctx: RequestContext);
+    /**
+     * Subscribe to all events for authenticated client
+     *
+     * Opens an SSE connection to receive real-time events for all jobs.
+     * Requires an SSE token obtained via client.auth.generateSSEToken().
+     *
+     * Event Types:
+     * - Job lifecycle: job.created, job.queued, job.started, job.progress,
+     *   job.completed, job.failed, job.cancelled
+     * - Job details: job.log, job.metric, job.alert, job.checkpoint
+     * - Deals: deal.found, deal.validated
+     * - System: ping, connection.open, connection.close, error
+     *
+     * Features:
+     * - Automatic reconnection on disconnect
+     * - Event replay via Last-Event-ID
+     * - Keepalive pings every 15 seconds
+     * - Max connection time: 1 hour
+     *
+     * @param token - SSE authentication token from client.auth.generateSSEToken()
+     * @param options - Subscription options (callbacks, reconnection settings)
+     *
+     * @example
+     * ```ts
+     * // Generate token
+     * const { token } = await client.auth.generateSSEToken();
+     *
+     * // Subscribe with event handlers
+     * const eventSource = client.events.subscribe(token, {
+     *   onEvent: (event) => {
+     *     // Handle all events
+     *     console.log('Event:', event.type);
+     *     const data = JSON.parse(event.data);
+     *
+     *     if (data.jobId) {
+     *       console.log(`Job ${data.jobId}:`, data);
+     *     }
+     *   },
+     *   onError: (error) => {
+     *     console.error('SSE error:', error);
+     *   },
+     *   onOpen: () => {
+     *     console.log('SSE connection opened');
+     *   }
+     * });
+     *
+     * // Listen for specific event types
+     * eventSource.addEventListener('job.completed', (event) => {
+     *   const data = JSON.parse(event.data);
+     *   console.log('Job completed:', data);
+     * });
+     *
+     * // Clean up
+     * eventSource.close();
+     * ```
+     */
+    subscribe(token: string, options?: Omit<SSESubscribeOptions, "lastEventId">): EventSource;
+    /**
+     * Subscribe to events for a specific job
+     *
+     * Opens an SSE connection filtered to a single job.
+     * More efficient than global subscription when tracking one job.
+     *
+     * @param jobId - Job ID to subscribe to
+     * @param token - SSE authentication token
+     * @param options - Subscription options
+     *
+     * @example
+     * ```ts
+     * // Start a scrape job
+     * const job = await client.scrape.create({ url: "https://example.com" });
+     *
+     * // Generate SSE token for this job
+     * const { token } = await client.auth.generateSSEToken({ jobId: job.jobId });
+     *
+     * // Subscribe to job events
+     * const eventSource = client.events.subscribeToJob(job.jobId, token, {
+     *   onEvent: (event) => {
+     *     const data = JSON.parse(event.data);
+     *     console.log(`[${event.type}]`, data);
+     *   }
+     * });
+     *
+     * // Listen for completion
+     * eventSource.addEventListener('job.completed', (event) => {
+     *   const data = JSON.parse(event.data);
+     *   console.log('Scrape completed!', data.summary);
+     *   eventSource.close();
+     * });
+     *
+     * // Listen for progress
+     * eventSource.addEventListener('job.progress', (event) => {
+     *   const data = JSON.parse(event.data);
+     *   console.log(`Progress: ${data.progress}%`);
+     * });
+     *
+     * // Listen for errors
+     * eventSource.addEventListener('job.failed', (event) => {
+     *   const data = JSON.parse(event.data);
+     *   console.error('Job failed:', data.error);
+     *   eventSource.close();
+     * });
+     * ```
+     */
+    subscribeToJob(jobId: string, token: string, options?: Omit<SSESubscribeOptions, "lastEventId">): EventSource;
+    /**
+     * Helper: Wait for job completion via SSE
+     *
+     * Convenience method that subscribes to a job and resolves when complete.
+     * Automatically handles token generation and cleanup.
+     *
+     * @param jobId - Job ID to wait for
+     * @param onProgress - Optional progress callback
+     *
+     * @example
+     * ```ts
+     * const job = await client.scrape.create({ url: "https://example.com" });
+     *
+     * // Wait for completion with progress updates
+     * const result = await client.events.waitForCompletion(job.jobId, (progress) => {
+     *   console.log(`Progress: ${progress}%`);
+     * });
+     *
+     * console.log('Job completed:', result);
+     * ```
+     */
+    waitForCompletion<T = unknown>(jobId: string, onProgress?: (progress: number) => void): Promise<T>;
+}
+
 /**
  * Extract Resource
  * Handles LLM-based structured data extraction
@@ -2594,7 +3224,9 @@ declare class KeysResource {
      */
     revokeAll(): Promise<{
         success: boolean;
-        count: number;
+        revokedCount: number;
+        message: string;
+        warning: string;
     }>;
     /**
      * Get active keys only
@@ -2689,7 +3321,8 @@ declare class ScrapeResource {
      *     { url: "https://shop1.com/product1" },
      *     { url: "https://shop2.com/deal", extractDeal: true }
      *   ],
-     *   defaults: { detectSignals: true }
+     *   defaults: { detectSignals: true },
+     *   ignoreInvalidURLs: true
      * });
      * console.log(batch.batchId, batch.results);
      * ```
@@ -2720,6 +3353,58 @@ declare class ScrapeResource {
     batchForDeals(urls: string[], options?: Omit<BatchScrapeOptions, "urls">): Promise<BatchScrapeResponse>;
 }
 
+/**
+ * Screenshots Resource
+ * Handles screenshot signed URL refresh and TTL limits
+ */
+
+/**
+ * Options for refreshing a screenshot signed URL
+ */
+interface RefreshScreenshotOptions {
+    /** File path in storage (e.g., "job_abc123/timestamp_id_url.png") */
+    path: string;
+    /** Optional: New TTL in seconds (must be within tier limits) */
+    ttl?: number;
+    /** Optional: Bucket name (defaults to 'screenshots-private') */
+    bucket?: string;
+}
+/**
+ * Screenshots resource class
+ * Provides methods for managing screenshot signed URLs
+ */
+declare class ScreenshotsResource {
+    private ctx;
+    constructor(ctx: RequestContext);
+    /**
+     * Refresh a signed URL before expiration
+     *
+     * @example
+     * ```ts
+     * const refreshed = await client.screenshots.refresh({
+     *   path: "job_abc123/1234567890_nanoid_example.png",
+     *   ttl: 604800  // 7 days
+     * });
+     * console.log(refreshed.url);           // New signed URL
+     * console.log(refreshed.expiresAt);     // "2026-01-25T12:00:00Z"
+     * console.log(refreshed.tierLimits);    // { min: 3600, max: 604800, default: 604800 }
+     * ```
+     */
+    refresh(options: RefreshScreenshotOptions): Promise<ScreenshotRefreshResponse>;
+    /**
+     * Get TTL limits for the current tier
+     *
+     * @example
+     * ```ts
+     * const limits = await client.screenshots.getLimits();
+     * console.log(limits.tier);                    // "pro"
+     * console.log(limits.limits.max);              // 604800 (7 days in seconds)
+     * console.log(limits.formattedLimits.max);     // "7 days"
+     * ```
+     */
+    getLimits(): Promise<ScreenshotLimitsResponse>;
+}
+
 /**
  * Search Resource
  * Handles web search operations with AI optimization
@@ -2739,7 +3424,7 @@ declare class SearchResource {
      * ```ts
      * const result = await client.search.create({
      *   query: "laptop deals black friday",
-     *   maxResults: 20,
+     *   limit: 20,
      *   useDealScoring: true
      * });
      * ```
@@ -2775,12 +3460,12 @@ declare class SearchResource {
      * @example
      * ```ts
      * const result = await client.search.andScrape("promo codes", {
-     *   autoScrapeLimit: 5
+     *   maxScrapeResults: 5
      * });
      * console.log(result.data.scrapedJobIds);
      * ```
      */
-    andScrape(query: string, options?: Omit<SearchOptions, "query" | "autoScrape">): Promise<SearchJobResponse>;
+    andScrape(query: string, options?: Omit<SearchOptions, "query" | "scrapeResults">): Promise<SearchJobResponse>;
     /**
      * Check search API status
      * Returns availability and features info
@@ -3056,6 +3741,9 @@ declare class WebhooksResource {
  * await client.extract.create({ url: "...", schema: {...} });
  * await client.dork.create({ query: "..." });
  *
+ * // Utilities
+ * await client.convert.htmlToMarkdown({ html: "..." });
+ *
  * // Status & polling
  * await client.status.get(jobId);
  * await client.waitForResult(jobId);
@@ -3147,6 +3835,20 @@ declare class DealCrawl {
      * ```
      */
     readonly dork: DorkResource;
+    /**
+     * Convert resource - HTML to Markdown conversion
+     *
+     * @example
+     * ```ts
+     * const result = await client.convert.htmlToMarkdown({
+     *   html: "<h1>Title</h1><p>Content</p>",
+     *   baseUrl: "https://example.com",
+     *   options: { removeNoise: true }
+     * });
+     * console.log(result.data.markdown);
+     * ```
+     */
+    readonly convert: ConvertResource;
     /**
      * Agent resource - AI-powered autonomous web navigation
      *
@@ -3228,6 +3930,80 @@ declare class DealCrawl {
      * ```
      */
     readonly account: AccountResource;
+    /**
+     * Screenshots resource - Screenshot signed URL management
+     *
+     * @example
+     * ```ts
+     * // Refresh a signed URL before expiration
+     * const refreshed = await client.screenshots.refresh({
+     *   path: "job_abc123/1234567890_nanoid_example.png",
+     *   ttl: 604800  // 7 days
+     * });
+     *
+     * // Get tier-specific TTL limits
+     * const limits = await client.screenshots.getLimits();
+     * console.log(limits.formattedLimits.max);  // "7 days"
+     * ```
+     */
+    readonly screenshots: ScreenshotsResource;
+    /**
+     * Auth resource - SSE (Server-Sent Events) authentication
+     *
+     * @example
+     * ```ts
+     * // Generate SSE token for browser EventSource
+     * const { token, expiresAt } = await client.auth.generateSSEToken();
+     *
+     * // Use in browser
+     * const eventSource = new EventSource(`/v1/events?token=${token}`);
+     *
+     * // Generate token for specific job
+     * const jobToken = await client.auth.generateSSEToken({ jobId: "job_123" });
+     *
+     * // Check connection limits
+     * const limits = await client.auth.getLimits();
+     * console.log(`Available connections: ${limits.sse.available}`);
+     * ```
+     */
+    readonly auth: AuthResource;
+    /**
+     * Events resource - Real-time SSE event streaming (Browser only)
+     *
+     * IMPORTANT: This resource only works in browsers. For Node.js, use polling via client.status.get()
+     *
+     * @example Browser Usage
+     * ```ts
+     * // 1. Generate SSE token
+     * const { token } = await client.auth.generateSSEToken();
+     *
+     * // 2. Subscribe to all events
+     * const eventSource = client.events.subscribe(token, {
+     *   onEvent: (event) => {
+     *     console.log('Event:', event.type, JSON.parse(event.data));
+     *   }
+     * });
+     *
+     * // 3. Or subscribe to specific job
+     * const jobEvents = client.events.subscribeToJob('job_123', token, {
+     *   onEvent: (event) => {
+     *     const data = JSON.parse(event.data);
+     *     console.log(`Progress: ${data.progress}%`);
+     *   }
+     * });
+     *
+     * // 4. Listen for specific events
+     * eventSource.addEventListener('job.completed', (event) => {
+     *   const data = JSON.parse(event.data);
+     *   console.log('Job completed!', data.summary);
+     *   eventSource.close();
+     * });
+     *
+     * // 5. Clean up
+     * eventSource.close();
+     * ```
+     */
+    readonly events: EventsResource;
     /**
      * Create a new DealCrawl client
      *
@@ -3635,4 +4411,352 @@ declare const ERROR_MESSAGES: Record<ErrorCode, string>;
  */
 declare function getErrorMessage(code: ErrorCode): string;
 
-export { ALL_API_KEY_SCOPES, type AccountInfoResponse, type AccountMetricsResponse, AccountResource, type ActionBaseOptions, type ActionInput, type AgentAction, type AgentActionType, type AgentCompletionReason, type AgentJobResponse, type AgentModel, type AgentOptions, AgentResource, type AgentResultResponse, type AgentStatusResponse, type AgentStepResponse, type ApiError, type ApiKeyInfo, type ApiKeyScope, type ApiResponse, type BatchScrapeDefaults, type BatchScrapeItem, type BatchScrapeOptions, type BatchScrapeResponse, type BatchScrapeResultItem, type BatchStatusResponse, type CancelJobResponse, type CheckpointInfo, type ClickAction, type ClientPreferences, type ClientStatsResponse, type CrawlAnalysisResponse, type CrawlError, type CrawlJobResponse, type CrawlMode, type CrawlOptions, type CrawlRecommendation, CrawlResource, type CrawlResult, type CrawlStats, type CrawlTemplate, type CrawlTemplateId, type CreateApiKeyOptions, type CreateKeyResponse, type CreateWebhookOptions, type CreateWebhookResponse, type CreatedApiKey, DEFAULT_API_KEY_SCOPES, DEFAULT_CONFIG, DataResource, DealCrawl, type DealCrawlConfig, DealCrawlError, type DealDetails, type DealItem, type DealMetrics, type DealScoreSummary, type DealSummary, type DealUpMetrics, type DealUpMetricsResponse, type DeleteKeyResponse, type DeleteWebhookResponse, type DiscountSignal, type DorkJobResponse, type DorkOptions, DorkResource, type DorkResult, ERROR_CODES, ERROR_MESSAGES, type EngineSelection, type EngineType, type ErrorCode, type ExportDealsOptions, type ExportFormat, type ExportJobsOptions, type ExtractJobResponse, type ExtractModel, type ExtractOptions, ExtractResource, type ExtractedDeal, type ExtractionErrorDetails, type FallbackConfig, type FallbackMetadata, type FallbackResult, type FallbackSource, type GetApiKeyStatsOptions, type GetDealsOptions, type HoverAction, type JobDealsResponse, type JobMetricsResponse, type JobResponse, type JobStatus, type JobStatusFilter, type JobStatusResponse, type JobSummary, type JobTypeFilter, type KeyStatsResponse, KeysResource, type ListApiKeysOptions, type ListDealsOptions, type ListDealsResponse, type ListJobsOptions, type ListJobsResponse, type ListKeysResponse, type ListWebhooksResponse, type PaginatedResponse, type PaginationInfo, type ParsedPage, type PreferencesResponse, type PressAction, type PriceSignal, type PricingInfo, type ProductCategory, type ProductInfo, type RateLimitInfo, type RecommendationsResponse, type RequestContext, type ResumeJobResponse, type RevokeApiKeyOptions, type RotateApiKeyOptions, type RotateKeyResponse, type ScrapeJobResponse, type ScrapeOptions, ScrapeResource, type ScrapeResult, type ScreenshotAction, type ScreenshotAgentAction, type ScreenshotOptions, type ScreenshotResult, type ScrollAction, type SearchAiModel, type SearchAiProvider, type SearchData, type SearchDateRange, type SearchFilters, type SearchJobResponse, type SearchOptions, SearchResource, type SearchResultItem, type SearchStatusResponse, type SelectAction, type ClickAction$1 as SharedClickAction, type HoverAction$1 as SharedHoverAction, type PressAction$1 as SharedPressAction, type ScrollAction$1 as SharedScrollAction, type SelectAction$1 as SharedSelectAction, type WaitAction$1 as SharedWaitAction, type WriteAction$1 as SharedWriteAction, type Signal, type SortOrder, StatusResource, type TestWebhookResponse, type UpdatePreferencesOptions, type UpdatePreferencesResponse, type UpdateWebhookOptions, type UpdateWebhookResponse, type UrgencyLevel, type UsageStats, type ValidationError, type ValidationResult, type WaitAction, type WaitOptions, type WaitResult, type WebhookEvent, type WebhookItem, WebhooksResource, type WriteAction, DealCrawl as default, getErrorMessage, pollUntil, waitForAll, waitForAny, waitForResult };
+/**
+ * Advanced Job Status System
+ *
+ * Production-grade status model with:
+ * - Primary status (lifecycle stage)
+ * - Sub-status (detailed state within stage)
+ * - Reason codes (why this state was reached)
+ * - State machine transitions (valid state changes)
+ *
+ * @module job-status
+ */
+/**
+ * Primary job status - represents the main lifecycle stage
+ */
+type JobStatus = "queued" | "scheduled" | "priority_queued" | "initializing" | "active" | "processing" | "extracting" | "uploading" | "finalizing" | "retrying" | "backing_off" | "paused" | "pausing" | "resuming" | "completed" | "partial" | "failed" | "timeout" | "cancelled" | "rejected" | "stale" | "zombie" | "stuck";
+/**
+ * Sub-status provides granular detail within a primary status
+ */
+type JobSubStatus = "waiting_for_worker" | "waiting_for_rate_limit" | "waiting_for_quota" | "waiting_for_retry" | "waiting_for_dependency" | "launching_browser" | "establishing_connection" | "loading_config" | "validating_input" | "fetching_page" | "executing_javascript" | "waiting_for_render" | "detecting_signals" | "crawling_links" | "capturing_screenshot" | "calling_llm" | "parsing_response" | "validating_extraction" | "uploading_screenshot" | "uploading_artifacts" | "generating_signed_url" | "saving_to_database" | "cleaning_resources" | "sending_webhook" | "syncing_to_dealup" | "exponential_backoff" | "rate_limit_backoff" | "circuit_breaker_open" | "network_error" | "timeout_error" | "bot_detected" | "captcha_detected" | "auth_required" | "page_not_found" | "server_error" | "parse_error" | "extraction_failed" | "quota_exceeded" | "invalid_input" | "resource_unavailable" | "no_heartbeat" | "progress_stalled" | "worker_lost";
+/**
+ * Reason codes - why a status/substatus was reached
+ */
+type StatusReason = "job_completed_successfully" | "partial_results_available" | "added_to_queue" | "priority_elevated" | "rate_limit_applied" | "quota_check_pending" | "transient_network_error" | "rate_limit_exceeded" | "timeout_exceeded" | "worker_crashed" | "max_retries_not_reached" | "max_retries_exceeded" | "permanent_error" | "blocked_by_site" | "captcha_required" | "invalid_url_format" | "ssrf_detected" | "quota_exhausted" | "tier_restriction" | "resource_not_available" | "cancelled_by_user" | "cancelled_by_system" | "duplicate_detected" | "policy_violation" | "heartbeat_timeout" | "progress_timeout" | "worker_unresponsive";
+
+/**
+ * Professional structured logger for DealCrawl
+ * - Environment-aware (verbose in dev, minimal in prod)
+ * - Structured JSON output in production
+ * - Colored console output in development
+ * - Correlation ID support for request tracing
+ */
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+/**
+ * SSE (Server-Sent Events) Event Types
+ *
+ * Defines all events that can be pushed to clients via SSE.
+ *
+ * @module sse-events
+ */
+
+/**
+ * SSE event types - used as the "event:" field in SSE messages
+ */
+type SSEEventType = "job.created" | "job.queued" | "job.started" | "job.status" | "job.progress" | "job.completed" | "job.failed" | "job.cancelled" | "job.paused" | "job.resumed" | "job.log" | "job.metric" | "job.alert" | "job.checkpoint" | "deal.found" | "deal.validated" | "ping" | "connection.open" | "connection.close" | "error";
+/**
+ * Base SSE event structure - all events extend this
+ */
+interface BaseSSEEvent {
+    /** Event type (used in SSE "event:" field) */
+    type: SSEEventType;
+    /** Unique event ID (for Last-Event-ID replay) */
+    id: string;
+    /** When this event was generated */
+    timestamp: string;
+    /** Job ID this event relates to (null for system events) */
+    jobId: string | null;
+    /** Client ID (for server-side filtering) */
+    clientId: string;
+}
+/**
+ * Job created event - sent when job is first created
+ */
+interface JobCreatedEvent extends BaseSSEEvent {
+    type: "job.created";
+    jobId: string;
+    data: {
+        jobType: "scrape" | "crawl" | "dork" | "extract" | "agent";
+        priority?: "high" | "medium" | "low";
+        template?: string;
+    };
+}
+/**
+ * Job queued event - sent when job enters queue
+ */
+interface JobQueuedEvent extends BaseSSEEvent {
+    type: "job.queued";
+    jobId: string;
+    data: {
+        queue: string;
+        position?: number;
+        estimatedWaitMs?: number;
+    };
+}
+/**
+ * Job started event - sent when worker picks up job
+ */
+interface JobStartedEvent extends BaseSSEEvent {
+    type: "job.started";
+    jobId: string;
+    data: {
+        workerId?: string;
+        startedAt: string;
+    };
+}
+/**
+ * Job status change event - sent on every status transition
+ */
+interface JobStatusEvent extends BaseSSEEvent {
+    type: "job.status";
+    jobId: string;
+    data: {
+        status: JobStatus;
+        subStatus?: JobSubStatus;
+        reason?: StatusReason;
+        message?: string;
+        previousStatus?: JobStatus;
+        progress: number;
+    };
+}
+/**
+ * Job progress event - sent periodically during processing
+ */
+interface JobProgressEvent extends BaseSSEEvent {
+    type: "job.progress";
+    jobId: string;
+    data: {
+        progress: number;
+        status: JobStatus;
+        subStatus?: JobSubStatus;
+        message?: string;
+        eta?: {
+            remainingMs: number;
+            remainingFormatted: string;
+        };
+        stats?: {
+            pagesProcessed?: number;
+            dealsFound?: number;
+            signalsDetected?: number;
+        };
+    };
+}
+/**
+ * Job completed event - sent when job finishes successfully
+ */
+interface JobCompletedEvent extends BaseSSEEvent {
+    type: "job.completed";
+    jobId: string;
+    data: {
+        statusUrl: string;
+        completedAt: string;
+        durationMs: number;
+        summary: {
+            success: boolean;
+            pagesProcessed?: number;
+            dealsFound?: number;
+            signalsDetected?: number;
+            hasScreenshot?: boolean;
+        };
+        result?: {
+            dealScore?: number;
+            topSignals?: string[];
+            dealTitle?: string;
+        };
+    };
+}
+/**
+ * Job failed event - sent when job fails
+ */
+interface JobFailedEvent extends BaseSSEEvent {
+    type: "job.failed";
+    jobId: string;
+    data: {
+        statusUrl: string;
+        failedAt: string;
+        durationMs: number;
+        error: {
+            code: string;
+            message: string;
+            recoverable: boolean;
+        };
+        retry?: {
+            attempt: number;
+            maxAttempts: number;
+            willRetry: boolean;
+            nextRetryAt?: string;
+        };
+    };
+}
+/**
+ * Job cancelled event - sent when job is cancelled
+ */
+interface JobCancelledEvent extends BaseSSEEvent {
+    type: "job.cancelled";
+    jobId: string;
+    data: {
+        cancelledAt: string;
+        cancelledBy: "user" | "system";
+        reason?: string;
+    };
+}
+/**
+ * Job paused event
+ */
+interface JobPausedEvent extends BaseSSEEvent {
+    type: "job.paused";
+    jobId: string;
+    data: {
+        pausedAt: string;
+        checkpoint?: {
+            lastProcessedUrl: string;
+            urlsProcessed: number;
+            urlsRemaining: number;
+        };
+    };
+}
+/**
+ * Job resumed event
+ */
+interface JobResumedEvent extends BaseSSEEvent {
+    type: "job.resumed";
+    jobId: string;
+    data: {
+        resumedAt: string;
+        fromCheckpoint: boolean;
+    };
+}
+/**
+ * Job log event - sent for important log messages
+ */
+interface JobLogEvent extends BaseSSEEvent {
+    type: "job.log";
+    jobId: string;
+    data: {
+        level: LogLevel;
+        message: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+/**
+ * Job metric event - sent for performance/business metrics
+ */
+interface JobMetricEvent extends BaseSSEEvent {
+    type: "job.metric";
+    jobId: string;
+    data: {
+        metric: string;
+        value: number;
+        unit?: string;
+    };
+}
+/**
+ * Job alert event - sent for important alerts (quota warnings, etc.)
+ */
+interface JobAlertEvent extends BaseSSEEvent {
+    type: "job.alert";
+    jobId: string;
+    data: {
+        severity: "info" | "warning" | "error" | "critical";
+        title: string;
+        message: string;
+        actionRequired?: boolean;
+    };
+}
+/**
+ * Job checkpoint event - sent when checkpoint is saved
+ */
+interface JobCheckpointEvent extends BaseSSEEvent {
+    type: "job.checkpoint";
+    jobId: string;
+    data: {
+        savedAt: string;
+        lastProcessedUrl: string;
+        urlsProcessed: number;
+        urlsRemaining: number;
+        canResume: boolean;
+    };
+}
+/**
+ * Deal found event - sent when a deal is detected
+ */
+interface DealFoundEvent extends BaseSSEEvent {
+    type: "deal.found";
+    jobId: string;
+    data: {
+        dealId?: string;
+        url: string;
+        title: string;
+        score: number;
+        price?: number;
+        discount?: number;
+        category?: string;
+        signals: string[];
+    };
+}
+/**
+ * Deal validated event - sent when deal is validated/scored
+ */
+interface DealValidatedEvent extends BaseSSEEvent {
+    type: "deal.validated";
+    jobId: string;
+    data: {
+        dealId: string;
+        score: number;
+        confidence: number;
+        accepted: boolean;
+        rejectionReason?: string;
+    };
+}
+/**
+ * Ping event - keepalive to prevent connection timeout
+ */
+interface PingEvent extends BaseSSEEvent {
+    type: "ping";
+    jobId: null;
+    data: {
+        serverTime: string;
+    };
+}
+/**
+ * Connection open event - sent when SSE connection established
+ */
+interface ConnectionOpenEvent extends BaseSSEEvent {
+    type: "connection.open";
+    jobId: null;
+    data: {
+        clientId: string;
+        reconnected: boolean;
+        lastEventId?: string;
+    };
+}
+/**
+ * Connection close event - sent before connection closes
+ */
+interface ConnectionCloseEvent extends BaseSSEEvent {
+    type: "connection.close";
+    jobId: null;
+    data: {
+        reason: string;
+    };
+}
+/**
+ * Error event - sent when an error occurs
+ */
+interface ErrorEvent extends BaseSSEEvent {
+    type: "error";
+    jobId: string | null;
+    data: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    };
+}
+/**
+ * All possible SSE events (discriminated union)
+ */
+type SSEEvent = JobCreatedEvent | JobQueuedEvent | JobStartedEvent | JobStatusEvent | JobProgressEvent | JobCompletedEvent | JobFailedEvent | JobCancelledEvent | JobPausedEvent | JobResumedEvent | JobLogEvent | JobMetricEvent | JobAlertEvent | JobCheckpointEvent | DealFoundEvent | DealValidatedEvent | PingEvent | ConnectionOpenEvent | ConnectionCloseEvent | ErrorEvent;
+
+export { ALL_API_KEY_SCOPES, type AccountInfoResponse, type AccountMetricsResponse, AccountResource, type ActionBaseOptions, type ActionInput, type AgentAction, type AgentActionType, type AgentCompletionReason, type AgentJobResponse, type AgentModel, type AgentOptions, AgentResource, type AgentResultResponse, type AgentStatusResponse, type AgentStepResponse, type ApiError, type ApiKeyInfo, type ApiKeyScope, type ApiResponse, AuthResource, type BaseSSEEvent, type BatchScrapeDefaults, type BatchScrapeItem, type BatchScrapeOptions, type BatchScrapeResponse, type BatchScrapeResultItem, type BatchStatusResponse, type CancelJobResponse, type CheckpointInfo, type ClickAction, type ClientPreferences, type ClientStatsResponse, type ConnectionCloseEvent, type ConnectionOpenEvent, type ConversionMetadata, type ConvertOptions, ConvertResource, type ConvertResponse, type CrawlAnalysisResponse, type CrawlError, type CrawlJobResponse, type CrawlMode, type CrawlOptions, type CrawlRecommendation, CrawlResource, type CrawlResult, type CrawlStats, type CrawlTemplate, type CrawlTemplateId, type CreateApiKeyOptions, type CreateKeyResponse, type CreateWebhookOptions, type CreateWebhookResponse, type CreatedApiKey, DEFAULT_API_KEY_SCOPES, DEFAULT_CONFIG, DataResource, DealCrawl, type DealCrawlConfig, DealCrawlError, type DealDetails, type DealFoundEvent, type DealItem, type DealMetrics, type DealScoreSummary, type DealSummary, type DealUpMetrics, type DealUpMetricsResponse, type DealValidatedEvent, type DeleteKeyResponse, type DeleteWebhookResponse, type DiscountSignal, type DorkJobResponse, type DorkOptions, DorkResource, type DorkResult, ERROR_CODES, ERROR_MESSAGES, type EngineSelection, type EngineType, type ErrorCode, type ErrorEvent, EventsResource, type ExportDealsOptions, type ExportFormat, type ExportJobsOptions, type ExtractJobResponse, type ExtractModel, type ExtractOptions, ExtractResource, type ExtractedDeal, type ExtractionErrorDetails, type FallbackConfig, type FallbackMetadata, type FallbackResult, type FallbackSource, type GenerateSSETokenOptions, type GetApiKeyStatsOptions, type GetDealsOptions, type HoverAction, type JobAlertEvent, type JobCancelledEvent, type JobCheckpointEvent, type JobCompletedEvent, type JobCreatedEvent, type JobDealsResponse, type JobFailedEvent, type JobLogEvent, type JobMetricEvent, type JobMetricsResponse, type JobPausedEvent, type JobProgressEvent, type JobQueuedEvent, type JobResponse, type JobResumedEvent, type JobStartedEvent, type JobStatus$1 as JobStatus, type JobStatusEvent, type JobStatusFilter, type JobStatusResponse, type JobSummary, type JobTypeFilter, type KeyStatsResponse, KeysResource, type ListApiKeysOptions, type ListDealsOptions, type ListDealsResponse, type ListJobsOptions, type ListJobsResponse, type ListKeysResponse, type ListWebhooksResponse, type PaginatedResponse, type PaginationInfo, type ParsedPage, type PingEvent, type PreferencesResponse, type PressAction, type PriceSignal, type PricingInfo, type ProductCategory, type ProductInfo, type RateLimitInfo, type RecommendationsResponse, type RefreshScreenshotOptions, type RequestContext, type ResumeJobResponse, type RevokeApiKeyOptions, type RotateApiKeyOptions, type RotateKeyResponse, type SSEConnectionLimitsResponse, type SSEEvent, type SSEEventType, type SSESubscribeOptions, type SSETokenResponse, type ScrapeJobResponse, type ScrapeOptions, ScrapeResource, type ScrapeResult, type ScreenshotAction, type ScreenshotAgentAction, type ScreenshotLimitsResponse, type ScreenshotOptions, type ScreenshotRefreshResponse, type ScreenshotResult, ScreenshotsResource, type ScrollAction, type SearchAiModel, type SearchAiProvider, type SearchData, type SearchDateRange, type SearchFilters, type SearchJobResponse, type SearchOptions, SearchResource, type SearchResultItem, type SearchStatusResponse, type SelectAction, type ClickAction$1 as SharedClickAction, type HoverAction$1 as SharedHoverAction, type PressAction$1 as SharedPressAction, type ScrollAction$1 as SharedScrollAction, type SelectAction$1 as SharedSelectAction, type WaitAction$1 as SharedWaitAction, type WriteAction$1 as SharedWriteAction, type Signal, type SortOrder, StatusResource, type TestWebhookResponse, type UpdatePreferencesOptions, type UpdatePreferencesResponse, type UpdateWebhookOptions, type UpdateWebhookResponse, type UrgencyLevel, type UsageStats, type ValidationError, type ValidationResult, type WaitAction, type WaitOptions, type WaitResult, type WebhookEvent, type WebhookItem, WebhooksResource, type WriteAction, DealCrawl as default, getErrorMessage, pollUntil, waitForAll, waitForAny, waitForResult };