@dealcrawl/sdk 2.1.0 → 2.1.3

package/dist/index.mjs

@@ -0,0 +1,2260 @@
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.dealcrawl.dev",
+  timeout: 3e4,
+  maxRetries: 3,
+  retryDelay: 1e3
+};
+
+// src/error.ts
+var ERROR_CODES = {
+  // Authentication
+  INVALID_API_KEY: "INVALID_API_KEY",
+  MISSING_API_KEY: "MISSING_API_KEY",
+  API_KEY_EXPIRED: "API_KEY_EXPIRED",
+  ACCOUNT_SUSPENDED: "ACCOUNT_SUSPENDED",
+  // Rate limiting
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+  // Validation
+  INVALID_URL: "INVALID_URL",
+  INVALID_REQUEST: "INVALID_REQUEST",
+  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
+  // Job errors
+  JOB_NOT_FOUND: "JOB_NOT_FOUND",
+  JOB_FAILED: "JOB_FAILED",
+  JOB_TIMEOUT: "JOB_TIMEOUT",
+  // Scraping errors
+  FETCH_FAILED: "FETCH_FAILED",
+  PARSE_FAILED: "PARSE_FAILED",
+  BLOCKED_BY_ROBOTS: "BLOCKED_BY_ROBOTS",
+  CAPTCHA_DETECTED: "CAPTCHA_DETECTED",
+  SITE_UNREACHABLE: "SITE_UNREACHABLE",
+  // System errors
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  REDIS_ERROR: "REDIS_ERROR",
+  DATABASE_ERROR: "DATABASE_ERROR"
+};
+var DealCrawlError = class _DealCrawlError extends Error {
+  /** Error code from ERROR_CODES */
+  code;
+  /** HTTP status code from the API response */
+  statusCode;
+  /** Additional error details */
+  details;
+  /** Retry-After header value in seconds (for rate limiting) */
+  retryAfter;
+  constructor(options) {
+    super(options.message);
+    this.name = "DealCrawlError";
+    this.code = options.code;
+    this.statusCode = options.statusCode ?? 500;
+    this.details = options.details;
+    this.retryAfter = options.retryAfter;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _DealCrawlError);
+    }
+  }
+  /**
+   * Check if the error is retryable
+   * Rate limits and transient errors are retryable
+   */
+  isRetryable() {
+    const retryableCodes = [
+      ERROR_CODES.RATE_LIMIT_EXCEEDED,
+      ERROR_CODES.SERVICE_UNAVAILABLE,
+      ERROR_CODES.REDIS_ERROR,
+      ERROR_CODES.DATABASE_ERROR
+    ];
+    return retryableCodes.includes(this.code);
+  }
+  /**
+   * Check if the error is due to authentication issues
+   */
+  isAuthError() {
+    const authCodes = [
+      ERROR_CODES.INVALID_API_KEY,
+      ERROR_CODES.MISSING_API_KEY,
+      ERROR_CODES.API_KEY_EXPIRED,
+      ERROR_CODES.ACCOUNT_SUSPENDED
+    ];
+    return authCodes.includes(this.code);
+  }
+  /**
+   * Check if the error is due to rate limiting
+   */
+  isRateLimited() {
+    return this.code === ERROR_CODES.RATE_LIMIT_EXCEEDED;
+  }
+  /**
+   * Check if the error is due to quota exceeded
+   */
+  isQuotaExceeded() {
+    return this.code === ERROR_CODES.QUOTA_EXCEEDED;
+  }
+  /**
+   * Convert error to JSON-serializable object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      details: this.details,
+      retryAfter: this.retryAfter
+    };
+  }
+  /**
+   * Create a DealCrawlError from an API error response
+   */
+  static fromResponse(statusCode, body, retryAfter) {
+    const code = body.code || mapStatusCodeToErrorCode(statusCode);
+    const message = body.message || body.error || "An error occurred";
+    let parsedRetryAfter;
+    if (retryAfter !== null && retryAfter !== void 0) {
+      parsedRetryAfter = typeof retryAfter === "string" ? parseInt(retryAfter, 10) : retryAfter;
+      if (isNaN(parsedRetryAfter)) {
+        parsedRetryAfter = void 0;
+      }
+    } else if (body.retryAfter !== void 0) {
+      parsedRetryAfter = body.retryAfter;
+    }
+    return new _DealCrawlError({
+      code,
+      message,
+      statusCode,
+      details: body.details,
+      retryAfter: parsedRetryAfter
+    });
+  }
+};
+function mapStatusCodeToErrorCode(statusCode) {
+  switch (statusCode) {
+    case 400:
+      return ERROR_CODES.INVALID_REQUEST;
+    case 401:
+      return ERROR_CODES.INVALID_API_KEY;
+    case 403:
+      return ERROR_CODES.ACCOUNT_SUSPENDED;
+    case 404:
+      return ERROR_CODES.JOB_NOT_FOUND;
+    case 429:
+      return ERROR_CODES.RATE_LIMIT_EXCEEDED;
+    case 500:
+      return ERROR_CODES.INTERNAL_ERROR;
+    case 503:
+      return ERROR_CODES.SERVICE_UNAVAILABLE;
+    default:
+      return ERROR_CODES.INTERNAL_ERROR;
+  }
+}
+
+// src/utils/request.ts
+function buildQueryString(params) {
+  const entries = Object.entries(params).filter(([, value]) => value !== void 0).map(
+    ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+  );
+  return entries.length > 0 ? `?${entries.join("&")}` : "";
+}
+function parseRateLimitHeaders(headers) {
+  return {
+    limit: parseInt(headers.get("X-RateLimit-Limit") || "0", 10) || 0,
+    remaining: parseInt(headers.get("X-RateLimit-Remaining") || "0", 10) || 0,
+    reset: parseInt(headers.get("X-RateLimit-Reset") || "0", 10) || 0
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function request(ctx, path, options = {}) {
+  const { method = "GET", body, query, timeout, signal } = options;
+  const queryString = query ? buildQueryString(query) : "";
+  const url = `${ctx.baseUrl}${path}${queryString}`;
+  const timeoutMs = timeout ?? ctx.timeout;
+  let currentController = null;
+  const onAbort = () => {
+    if (currentController) {
+      currentController.abort();
+    }
+  };
+  if (signal) {
+    signal.addEventListener("abort", onAbort);
+  }
+  const cleanupExternalSignal = () => {
+    if (signal) {
+      signal.removeEventListener("abort", onAbort);
+    }
+  };
+  let lastError = null;
+  let attempt = 0;
+  while (attempt <= ctx.maxRetries) {
+    const controller = new AbortController();
+    currentController = controller;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    let attemptCleanupDone = false;
+    const cleanupAttempt = () => {
+      if (attemptCleanupDone) return;
+      attemptCleanupDone = true;
+      clearTimeout(timeoutId);
+      currentController = null;
+    };
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${ctx.apiKey}`
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      cleanupAttempt();
+      const rateLimit = parseRateLimitHeaders(response.headers);
+      if (response.status === 429) {
+        const retryAfter = parseInt(
+          response.headers.get("Retry-After") || "60",
+          10
+        );
+        if (ctx.onRateLimit) {
+          ctx.onRateLimit(rateLimit);
+        }
+        throw new DealCrawlError({
+          code: ERROR_CODES.RATE_LIMIT_EXCEEDED,
+          message: "Rate limit exceeded",
+          statusCode: 429,
+          retryAfter,
+          details: { rateLimit }
+        });
+      }
+      if (!response.ok) {
+        let errorBody = {};
+        try {
+          errorBody = await response.json();
+        } catch {
+        }
+        const retryAfterHeader = response.headers.get("Retry-After");
+        throw DealCrawlError.fromResponse(
+          response.status,
+          errorBody,
+          retryAfterHeader
+        );
+      }
+      let data;
+      const contentType = response.headers.get("Content-Type") || "";
+      if (contentType.includes("application/json")) {
+        data = await response.json();
+      } else if (contentType.includes("text/csv") || contentType.includes("text/plain")) {
+        data = await response.text();
+      } else {
+        data = await response.json();
+      }
+      cleanupExternalSignal();
+      return { data, rateLimit };
+    } catch (error) {
+      cleanupAttempt();
+      if (error instanceof Error && error.name === "AbortError") {
+        cleanupExternalSignal();
+        throw new DealCrawlError({
+          code: ERROR_CODES.JOB_TIMEOUT,
+          message: `Request timeout after ${timeoutMs}ms`,
+          statusCode: 408
+        });
+      }
+      if (error instanceof DealCrawlError) {
+        lastError = error;
+        if (error.isRetryable() && attempt < ctx.maxRetries) {
+          attempt++;
+          await sleep(ctx.retryDelay * attempt);
+          continue;
+        }
+        cleanupExternalSignal();
+        throw error;
+      }
+      cleanupExternalSignal();
+      throw new DealCrawlError({
+        code: ERROR_CODES.FETCH_FAILED,
+        message: error instanceof Error ? error.message : "Network request failed",
+        statusCode: 0
+      });
+    }
+  }
+  cleanupExternalSignal();
+  throw lastError ?? new DealCrawlError({
+    code: ERROR_CODES.INTERNAL_ERROR,
+    message: "Request failed after retries",
+    statusCode: 500
+  });
+}
+function get(ctx, path, query) {
+  return request(ctx, path, { method: "GET", query });
+}
+function post(ctx, path, body) {
+  return request(ctx, path, { method: "POST", body });
+}
+function patch(ctx, path, body) {
+  return request(ctx, path, { method: "PATCH", body });
+}
+function del(ctx, path, body) {
+  return request(ctx, path, { method: "DELETE", body });
+}
+
+// src/utils/polling.ts
+async function waitForResult(ctx, jobId, options = {}) {
+  const {
+    pollInterval = 2e3,
+    timeout = 3e5,
+    // 5 minutes
+    onProgress,
+    onStatusChange,
+    signal
+  } = options;
+  const startTime = Date.now();
+  let lastStatus = null;
+  while (true) {
+    if (signal?.aborted) {
+      throw new DealCrawlError({
+        code: ERROR_CODES.JOB_TIMEOUT,
+        message: "Wait cancelled by user",
+        statusCode: 0
+      });
+    }
+    const elapsed = Date.now() - startTime;
+    if (elapsed >= timeout) {
+      throw new DealCrawlError({
+        code: ERROR_CODES.JOB_TIMEOUT,
+        message: `Job did not complete within ${timeout}ms`,
+        statusCode: 408,
+        details: { jobId, elapsed }
+      });
+    }
+    const { data: status } = await get(
+      ctx,
+      `/v1/status/${jobId}`
+    );
+    if (onProgress) {
+      onProgress(status);
+    }
+    if (onStatusChange && lastStatus !== null && lastStatus !== status.status) {
+      onStatusChange(status.status, lastStatus);
+    }
+    lastStatus = status.status;
+    if (status.status === "completed") {
+      return {
+        jobId,
+        status: "completed",
+        result: status.result,
+        waitTime: Date.now() - startTime
+      };
+    }
+    if (status.status === "failed") {
+      return {
+        jobId,
+        status: "failed",
+        error: status.error,
+        waitTime: Date.now() - startTime
+      };
+    }
+    await sleep2(pollInterval);
+  }
+}
+async function waitForAll(ctx, jobIds, options = {}) {
+  const promises = jobIds.map((jobId) => waitForResult(ctx, jobId, options));
+  return Promise.all(promises);
+}
+async function waitForAny(ctx, jobIds, options = {}) {
+  const promises = jobIds.map((jobId) => waitForResult(ctx, jobId, options));
+  return Promise.race(promises);
+}
+async function pollUntil(fetchFn, conditionFn, options = {}) {
+  const { pollInterval = 2e3, timeout = 3e5, signal } = options;
+  const startTime = Date.now();
+  while (true) {
+    if (signal?.aborted) {
+      throw new Error("Polling cancelled");
+    }
+    if (Date.now() - startTime >= timeout) {
+      throw new Error(`Polling timeout after ${timeout}ms`);
+    }
+    const data = await fetchFn();
+    if (conditionFn(data)) {
+      return data;
+    }
+    await sleep2(pollInterval);
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/account.ts
+var AccountResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Get current account information
+   *
+   * @example
+   * ```ts
+   * const account = await client.account.get();
+   * console.log(account.name);
+   * console.log(account.tier);
+   * console.log(account.usage);
+   * ```
+   */
+  async get() {
+    const result = await get(this.ctx, "/v1/client");
+    return result.data;
+  }
+  /**
+   * Get detailed account metrics
+   *
+   * @example
+   * ```ts
+   * const metrics = await client.account.getMetrics();
+   * console.log(metrics.dealMetrics.totalDeals);
+   * console.log(metrics.categoryPerformance);
+   * ```
+   */
+  async getMetrics() {
+    const result = await get(
+      this.ctx,
+      "/v1/client/metrics"
+    );
+    return result.data;
+  }
+  /**
+   * Get DealUp sync metrics (pro/enterprise only)
+   *
+   * @example
+   * ```ts
+   * const dealup = await client.account.getDealUpMetrics();
+   * console.log(dealup.sync.totalSynced);
+   * console.log(dealup.sync.clicksGenerated);
+   * ```
+   */
+  async getDealUpMetrics() {
+    const result = await get(
+      this.ctx,
+      "/v1/client/dealup"
+    );
+    return result.data;
+  }
+  /**
+   * Get crawl recommendations
+   * AI-suggested URLs to crawl based on past performance
+   *
+   * @example
+   * ```ts
+   * const recommendations = await client.account.getRecommendations();
+   * recommendations.recommendations.forEach(r => {
+   *   console.log(r.url, r.reason, r.estimatedDeals);
+   * });
+   * ```
+   */
+  async getRecommendations() {
+    const result = await get(
+      this.ctx,
+      "/v1/client/recommendations"
+    );
+    return result.data;
+  }
+  /**
+   * Get current preferences
+   *
+   * @example
+   * ```ts
+   * const prefs = await client.account.getPreferences();
+   * console.log(prefs.preferences.minDealScore);
+   * console.log(prefs.preferences.autoSync);
+   * ```
+   */
+  async getPreferences() {
+    const result = await get(
+      this.ctx,
+      "/v1/client/preferences"
+    );
+    return result.data;
+  }
+  /**
+   * Update account preferences
+   *
+   * @example
+   * ```ts
+   * const updated = await client.account.updatePreferences({
+   *   minDealScore: 70,
+   *   autoSync: true,
+   *   preferredCategories: ["software", "courses"]
+   * });
+   * ```
+   */
+  async updatePreferences(options) {
+    const result = await patch(
+      this.ctx,
+      "/v1/client/preferences",
+      {
+        preferredCategories: options.preferredCategories,
+        minDealScore: options.minDealScore,
+        autoSync: options.autoSync,
+        webhookEnabled: options.webhookEnabled
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Track a DealUp click (webhook endpoint)
+   * Used internally by DealUp to track click-through
+   *
+   * @example
+   * ```ts
+   * await client.account.trackClick("deal_abc123", "homepage");
+   * ```
+   */
+  async trackClick(dealId, source) {
+    const result = await post(
+      this.ctx,
+      "/v1/client/dealup/click",
+      {
+        dealId,
+        source
+      }
+    );
+    return result.data;
+  }
+  // ============================================
+  // CONVENIENCE METHODS
+  // ============================================
+  /**
+   * Get remaining quota for a resource
+   *
+   * @example
+   * ```ts
+   * const remaining = await client.account.getRemainingQuota("scrapes");
+   * console.log(`${remaining} scrapes left this period`);
+   * ```
+   */
+  async getRemainingQuota(resource) {
+    const account = await this.get();
+    const usage = account.usage[resource];
+    return usage.limit - usage.used;
+  }
+  /**
+   * Check if account has quota for a resource
+   *
+   * @example
+   * ```ts
+   * if (await client.account.hasQuota("crawls", 5)) {
+   *   // Safe to start 5 crawls
+   * }
+   * ```
+   */
+  async hasQuota(resource, needed = 1) {
+    const remaining = await this.getRemainingQuota(resource);
+    return remaining >= needed;
+  }
+  /**
+   * Get account tier
+   *
+   * @example
+   * ```ts
+   * const tier = await client.account.getTier();
+   * if (tier === "enterprise") {
+   *   // Enable advanced features
+   * }
+   * ```
+   */
+  async getTier() {
+    const account = await this.get();
+    return account.tier;
+  }
+  /**
+   * Check if account is pro or enterprise tier
+   *
+   * @example
+   * ```ts
+   * if (await client.account.isPremium()) {
+   *   // Show premium features
+   * }
+   * ```
+   */
+  async isPremium() {
+    const tier = await this.getTier();
+    return tier === "pro" || tier === "enterprise";
+  }
+};
+
+// src/resources/crawl.ts
+var CRAWL_TEMPLATES = {
+  ecommerce: {
+    id: "ecommerce",
+    name: "E-commerce",
+    description: "Optimized for product pages and online stores",
+    defaultOptions: {
+      maxDepth: 3,
+      maxPages: 500,
+      delayMs: 1500,
+      extractDeal: true,
+      prioritizeDealPages: true,
+      excludePatterns: [
+        "*/cart*",
+        "*/checkout*",
+        "*/account*",
+        "*/login*",
+        "*/register*",
+        "*/wishlist*",
+        "*/compare*"
+      ]
+    }
+  },
+  blog: {
+    id: "blog",
+    name: "Blog",
+    description: "Optimized for blog posts and articles",
+    defaultOptions: {
+      maxDepth: 2,
+      maxPages: 200,
+      delayMs: 1e3,
+      extractDeal: false,
+      prioritizeDealPages: false,
+      excludePatterns: ["*/tag/*", "*/category/*", "*/author/*", "*/page/*"]
+    }
+  },
+  docs: {
+    id: "docs",
+    name: "Documentation",
+    description: "Optimized for documentation sites",
+    defaultOptions: {
+      maxDepth: 4,
+      maxPages: 300,
+      delayMs: 500,
+      extractDeal: false,
+      prioritizeDealPages: false
+    }
+  },
+  marketplace: {
+    id: "marketplace",
+    name: "Marketplace",
+    description: "Optimized for multi-vendor marketplaces",
+    defaultOptions: {
+      maxDepth: 3,
+      maxPages: 1e3,
+      delayMs: 2e3,
+      extractDeal: true,
+      prioritizeDealPages: true,
+      followExternalLinks: false,
+      excludePatterns: [
+        "*/seller/*",
+        "*/vendor/*",
+        "*/shop/*",
+        "*/reviews*",
+        "*/questions*"
+      ]
+    }
+  },
+  custom: {
+    id: "custom",
+    name: "Custom",
+    description: "No preset - use your own settings",
+    defaultOptions: {}
+  }
+};
+var CrawlResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Create a new crawl job
+   *
+   * @example
+   * ```ts
+   * const job = await client.crawl.create({
+   *   url: "https://example.com",
+   *   maxDepth: 3,
+   *   maxPages: 100,
+   *   extractDeal: true
+   * });
+   * console.log(job.jobId);
+   * ```
+   */
+  async create(options) {
+    const body = {
+      startUrl: options.url || options.startUrl,
+      url: options.url || options.startUrl,
+      prompt: options.prompt,
+      maxDepth: options.maxDepth,
+      maxPages: options.maxPages,
+      delayMs: options.delayMs,
+      detectSignals: options.detectSignals,
+      extractWithAI: options.extractWithAI,
+      extractDeal: options.extractDeal,
+      minDealScore: options.minDealScore,
+      prioritizeDealPages: options.prioritizeDealPages,
+      followExternalLinks: options.followExternalLinks,
+      allowedDomains: options.allowedDomains,
+      excludePatterns: options.excludePatterns
+    };
+    const result = await post(this.ctx, "/v1/crawl", body);
+    return result.data;
+  }
+  /**
+   * Create a crawl job using a template
+   *
+   * @example
+   * ```ts
+   * const job = await client.crawl.withTemplate("ecommerce", {
+   *   url: "https://shop.example.com",
+   *   maxPages: 200 // Override template default
+   * });
+   * ```
+   */
+  async withTemplate(templateId, options) {
+    const template = CRAWL_TEMPLATES[templateId];
+    if (!template) {
+      throw new Error(
+        `Invalid crawl templateId: ${templateId}. Available templates: ${Object.keys(CRAWL_TEMPLATES).join(", ")}`
+      );
+    }
+    return this.create({
+      ...template.defaultOptions,
+      ...options
+    });
+  }
+  /**
+   * List available crawl templates
+   *
+   * @example
+   * ```ts
+   * const templates = client.crawl.listTemplates();
+   * templates.forEach(t => console.log(t.name, t.description));
+   * ```
+   */
+  listTemplates() {
+    return Object.values(CRAWL_TEMPLATES);
+  }
+  /**
+   * Get a specific template by ID
+   *
+   * @example
+   * ```ts
+   * const template = client.crawl.getTemplate("ecommerce");
+   * console.log(template.defaultOptions);
+   * ```
+   */
+  getTemplate(templateId) {
+    return CRAWL_TEMPLATES[templateId];
+  }
+  /**
+   * Analyze a URL before crawling
+   * Returns recommended settings based on site structure
+   *
+   * @example
+   * ```ts
+   * const analysis = await client.crawl.analyze("https://shop.example.com");
+   * console.log(analysis.recommendedTemplate);
+   * console.log(analysis.estimatedPages);
+   * ```
+   */
+  async analyze(url) {
+    const result = await get(
+      this.ctx,
+      "/v1/crawl/analyze",
+      {
+        url
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Crawl a URL with deal extraction enabled
+   * Convenience method for e-commerce crawling
+   *
+   * @example
+   * ```ts
+   * const job = await client.crawl.forDeals("https://shop.example.com", {
+   *   minDealScore: 70
+   * });
+   * ```
+   */
+  async forDeals(url, options) {
+    return this.withTemplate("ecommerce", {
+      url,
+      extractDeal: true,
+      prioritizeDealPages: true,
+      ...options
+    });
+  }
+};
+
+// src/resources/data.ts
+var DataResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // ============================================
+  // JOBS
+  // ============================================
+  /**
+   * List all jobs
+   *
+   * @example
+   * ```ts
+   * const jobs = await client.data.listJobs({
+   *   status: "completed",
+   *   type: "crawl",
+   *   page: 1,
+   *   limit: 20
+   * });
+   * console.log(jobs.data);
+   * console.log(jobs.pagination.total);
+   * ```
+   */
+  async listJobs(options = {}) {
+    const result = await get(this.ctx, "/v1/data/jobs", {
+      page: options.page,
+      limit: options.limit,
+      status: options.status,
+      type: options.type,
+      sortBy: options.sortBy,
+      sortOrder: options.sortOrder,
+      fromDate: options.fromDate,
+      toDate: options.toDate
+    });
+    return result.data;
+  }
+  /**
+   * Get jobs by status
+   * Convenience method for filtering by status
+   *
+   * @example
+   * ```ts
+   * const activeJobs = await client.data.getJobsByStatus("active");
+   * ```
+   */
+  async getJobsByStatus(status, options) {
+    return this.listJobs({ status, ...options });
+  }
+  /**
+   * Get jobs by type
+   * Convenience method for filtering by type
+   *
+   * @example
+   * ```ts
+   * const crawlJobs = await client.data.getJobsByType("crawl");
+   * ```
+   */
+  async getJobsByType(type, options) {
+    return this.listJobs({ type, ...options });
+  }
+  /**
+   * Get recent jobs
+   * Convenience method for getting latest jobs
+   *
+   * @example
+   * ```ts
+   * const recentJobs = await client.data.getRecentJobs(10);
+   * ```
+   */
+  async getRecentJobs(limit = 10) {
+    return this.listJobs({
+      limit,
+      sortBy: "created_at",
+      sortOrder: "desc"
+    });
+  }
+  // ============================================
+  // DEALS
+  // ============================================
+  /**
+   * List all deals
+   *
+   * @example
+   * ```ts
+   * const deals = await client.data.listDeals({
+   *   minScore: 70,
+   *   category: "electronics",
+   *   sortBy: "deal_score",
+   *   sortOrder: "desc"
+   * });
+   * ```
+   */
+  async listDeals(options = {}) {
+    const result = await get(this.ctx, "/v1/data/deals", {
+      page: options.page,
+      limit: options.limit,
+      minScore: options.minScore,
+      maxPrice: options.maxPrice,
+      category: options.category,
+      merchant: options.merchant,
+      synced: options.synced?.toString(),
+      sortBy: options.sortBy,
+      sortOrder: options.sortOrder
+    });
+    return result.data;
+  }
+  /**
+   * Get a single deal by ID
+   *
+   * @example
+   * ```ts
+   * const deal = await client.data.getDeal("deal_abc123");
+   * console.log(deal.product.name);
+   * console.log(deal.pricing.discountPercent);
+   * ```
+   */
+  async getDeal(dealId) {
+    if (!dealId || !dealId.trim()) {
+      throw new Error("dealId is required and cannot be empty");
+    }
+    const result = await get(this.ctx, `/v1/data/deals/${dealId}`);
+    return result.data;
+  }
+  /**
+   * Get top deals by score
+   * Convenience method for finding best deals
+   *
+   * @example
+   * ```ts
+   * const topDeals = await client.data.getTopDeals(20, 80);
+   * ```
+   */
+  async getTopDeals(limit = 20, minScore = 70) {
+    return this.listDeals({
+      limit,
+      minScore,
+      sortBy: "deal_score",
+      sortOrder: "desc"
+    });
+  }
+  /**
+     * Get deals by category
+     * Convenience method for filtering by category
+     *
+     * @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 });
+    }
+  
+    /**
+     * Get unsynced deals (not yet sent to DealUp)
+     *
+     * @example
+     * ```ts
+     * const unsyncedDeals = await client.data.getUnsyncedDeals();
+     * ```
+     */
+  async getUnsyncedDeals(options) {
+    return this.listDeals({ synced: false, ...options });
+  }
+  // ============================================
+  // EXPORT
+  // ============================================
+  /**
+   * Export jobs data
+   *
+   * @example
+   * ```ts
+   * // Export as JSON
+   * const jsonData = await client.data.exportJobs({ format: "json" });
+   *
+   * // Export as CSV
+   * const csvData = await client.data.exportJobs({ format: "csv" });
+   * ```
+   */
+  async exportJobs(options = {}) {
+    const result = await get(
+      this.ctx,
+      "/v1/data/export/jobs",
+      {
+        format: options.format || "json",
+        status: options.status,
+        type: options.type,
+        fromDate: options.fromDate,
+        toDate: options.toDate
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Export deals data
+   *
+   * @example
+   * ```ts
+   * // Export as JSON
+   * const jsonData = await client.data.exportDeals({ format: "json" });
+   *
+   * // Export as CSV with filters
+   * const csvData = await client.data.exportDeals({
+   *   format: "csv",
+   *   minScore: 70,
+   *   category: "software"
+   * });
+   * ```
+   */
+  async exportDeals(options = {}) {
+    const result = await get(
+      this.ctx,
+      "/v1/data/export/deals",
+      {
+        format: options.format || "json",
+        minScore: options.minScore,
+        maxPrice: options.maxPrice,
+        category: options.category,
+        includeRawSignals: options.includeRawSignals
+      }
+    );
+    return result.data;
+  }
+  // ============================================
+  // STATS
+  // ============================================
+  /**
+   * Get client statistics
+   *
+   * @example
+   * ```ts
+   * const stats = await client.data.getStats();
+   * console.log(stats.totals.deals);
+   * console.log(stats.performance.avgDealScore);
+   * ```
+   */
+  async getStats() {
+    const result = await get(this.ctx, "/v1/data/stats");
+    return result.data;
+  }
+};
+
+// src/resources/dork.ts
+var DorkResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Create a new dork search job
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.create({
+   *   query: "discount coupon",
+   *   site: "amazon.com",
+   *   maxResults: 20
+   * });
+   * console.log(job.jobId);
+   * ```
+   */
+  async create(options) {
+    const body = {
+      query: this.buildQuery(options),
+      maxResults: options.maxResults,
+      region: options.region
+    };
+    const result = await post(this.ctx, "/v1/dork", body);
+    return result.data;
+  }
+  /**
+   * Search for deals on a specific site
+   * Convenience method for finding discount pages
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.findDeals("amazon.com", {
+   *   maxResults: 50
+   * });
+   * ```
+   */
+  async findDeals(site, options) {
+    return this.create({
+      query: "discount OR coupon OR sale OR promo OR deal",
+      site,
+      ...options
+    });
+  }
+  /**
+   * Search for product pages on a site
+   * Looks for common product URL patterns
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.findProducts("shop.example.com", {
+   *   maxResults: 100
+   * });
+   * ```
+   */
+  async findProducts(site, options) {
+    return this.create({
+      query: "product OR item OR buy",
+      site,
+      inUrl: "product",
+      ...options
+    });
+  }
+  /**
+   * Search for PDFs on a site
+   * Useful for finding manuals, guides, datasheets
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.findPDFs("docs.example.com", "user guide");
+   * ```
+   */
+  async findPDFs(site, query, options) {
+    return this.create({
+      query: query || "*",
+      site,
+      fileType: "pdf",
+      ...options
+    });
+  }
+  /**
+   * Search with custom title filter
+   * Find pages with specific terms in title
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.inTitle("Black Friday", {
+   *   site: "bestbuy.com",
+   *   maxResults: 30
+   * });
+   * ```
+   */
+  async inTitle(titleQuery, options) {
+    return this.create({
+      query: options?.query || titleQuery,
+      inTitle: titleQuery,
+      ...options
+    });
+  }
+  /**
+   * Search with custom URL filter
+   * Find pages with specific terms in URL
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.inUrl("clearance", {
+   *   site: "walmart.com"
+   * });
+   * ```
+   */
+  async inUrl(urlQuery, options) {
+    return this.create({
+      query: options?.query || urlQuery,
+      inUrl: urlQuery,
+      ...options
+    });
+  }
+  /**
+   * Build a raw Google dork query string
+   * Useful for preview or debugging
+   *
+   * @example
+   * ```ts
+   * const query = client.dork.buildQuery({
+   *   query: "laptop deals",
+   *   site: "amazon.com",
+   *   inTitle: "discount"
+   * });
+   * // Returns: "laptop deals site:amazon.com intitle:discount"
+   * ```
+   */
+  buildQuery(options) {
+    const parts = [];
+    if (typeof options.query === "string" && options.query.trim() !== "") {
+      parts.push(options.query);
+    }
+    if (options.site) {
+      parts.push(`site:${options.site}`);
+    }
+    if (options.fileType) {
+      parts.push(`filetype:${options.fileType}`);
+    }
+    if (options.inUrl) {
+      parts.push(`inurl:${options.inUrl}`);
+    }
+    if (options.inTitle) {
+      parts.push(`intitle:${options.inTitle}`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/resources/extract.ts
+var ExtractResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Create a new extraction job
+   * Either schema or prompt must be provided
+   *
+   * @example
+   * ```ts
+   * // Schema-based extraction
+   * const job = await client.extract.create({
+   *   url: "https://example.com/product",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       price: { type: "number" },
+   *       features: { type: "array", items: { type: "string" } }
+   *     }
+   *   }
+   * });
+   *
+   * // Prompt-based extraction
+   * const job = await client.extract.create({
+   *   url: "https://example.com/article",
+   *   prompt: "Extract the main points and author name"
+   * });
+   * ```
+   */
+  async create(options) {
+    if (!options.schema && !options.prompt) {
+      throw new Error("Either 'schema' or 'prompt' must be provided");
+    }
+    const body = {
+      url: options.url,
+      schema: options.schema,
+      prompt: options.prompt,
+      onlyMainContent: options.onlyMainContent,
+      excludeTags: options.excludeTags,
+      excludeSelectors: options.excludeSelectors,
+      model: options.model,
+      temperature: options.temperature,
+      webhook: options.webhook,
+      headers: options.headers,
+      timeout: options.timeout
+    };
+    const result = await post(
+      this.ctx,
+      "/v1/extract",
+      body
+    );
+    return result.data;
+  }
+  /**
+   * Extract data using a JSON Schema
+   * Convenience method for schema-based extraction
+   *
+   * @example
+   * ```ts
+   * const job = await client.extract.withSchema(
+   *   "https://example.com/product",
+   *   {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       price: { type: "number" }
+   *     }
+   *   }
+   * );
+   * ```
+   */
+  async withSchema(url, schema, options) {
+    return this.create({
+      url,
+      schema,
+      ...options
+    });
+  }
+  /**
+   * Extract data using a natural language prompt
+   * Convenience method for prompt-based extraction
+   *
+   * @example
+   * ```ts
+   * const job = await client.extract.withPrompt(
+   *   "https://example.com/article",
+   *   "Extract the article title, author, publication date, and a brief summary"
+   * );
+   * ```
+   */
+  async withPrompt(url, prompt, options) {
+    return this.create({
+      url,
+      prompt,
+      ...options
+    });
+  }
+  /**
+   * Extract product information from a page
+   * Pre-built schema for common e-commerce use case
+   *
+   * @example
+   * ```ts
+   * const job = await client.extract.product("https://shop.example.com/item");
+   * ```
+   */
+  async product(url, options) {
+    const productSchema = {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Product name" },
+        brand: { type: "string", description: "Brand name" },
+        price: { type: "number", description: "Current price" },
+        originalPrice: {
+          type: "number",
+          description: "Original price before discount"
+        },
+        currency: {
+          type: "string",
+          description: "Currency code (USD, EUR, etc.)"
+        },
+        description: { type: "string", description: "Product description" },
+        features: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of product features"
+        },
+        images: {
+          type: "array",
+          items: { type: "string" },
+          description: "Product image URLs"
+        },
+        availability: {
+          type: "string",
+          description: "In stock, out of stock, etc."
+        },
+        rating: { type: "number", description: "Average rating" },
+        reviewCount: { type: "number", description: "Number of reviews" }
+      },
+      required: ["name", "price"]
+    };
+    return this.create({
+      url,
+      schema: productSchema,
+      model: "gpt-4o-mini",
+      ...options
+    });
+  }
+  /**
+   * Extract article/blog post information
+   * Pre-built schema for content extraction
+   *
+   * @example
+   * ```ts
+   * const job = await client.extract.article("https://blog.example.com/post");
+   * ```
+   */
+  async article(url, options) {
+    const articleSchema = {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Article title" },
+        author: { type: "string", description: "Author name" },
+        publishedAt: { type: "string", description: "Publication date" },
+        summary: {
+          type: "string",
+          description: "Brief summary of the article"
+        },
+        content: { type: "string", description: "Main article content" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Article tags or categories"
+        },
+        readingTime: {
+          type: "number",
+          description: "Estimated reading time in minutes"
+        }
+      },
+      required: ["title", "content"]
+    };
+    return this.create({
+      url,
+      schema: articleSchema,
+      onlyMainContent: true,
+      ...options
+    });
+  }
+  /**
+   * Extract contact information from a page
+   * Pre-built schema for contact page scraping
+   *
+   * @example
+   * ```ts
+   * const job = await client.extract.contact("https://example.com/contact");
+   * ```
+   */
+  async contact(url, options) {
+    const contactSchema = {
+      type: "object",
+      properties: {
+        companyName: {
+          type: "string",
+          description: "Company or organization name"
+        },
+        email: { type: "string", description: "Contact email address" },
+        phone: { type: "string", description: "Phone number" },
+        address: {
+          type: "object",
+          properties: {
+            street: { type: "string" },
+            city: { type: "string" },
+            state: { type: "string" },
+            postalCode: { type: "string" },
+            country: { type: "string" }
+          },
+          description: "Physical address"
+        },
+        socialMedia: {
+          type: "object",
+          properties: {
+            twitter: { type: "string" },
+            linkedin: { type: "string" },
+            facebook: { type: "string" },
+            instagram: { type: "string" }
+          },
+          description: "Social media links"
+        }
+      }
+    };
+    return this.create({
+      url,
+      schema: contactSchema,
+      onlyMainContent: false,
+      // Contact info might be in footer
+      ...options
+    });
+  }
+};
+
+// src/resources/keys.ts
+var KeysResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List all API keys
+   *
+   * @example
+   * ```ts
+   * const keys = await client.keys.list();
+   * keys.keys.forEach(k => {
+   *   console.log(k.name, k.prefix, k.isActive);
+   * });
+   * ```
+   */
+  async list(options = {}) {
+    const result = await get(this.ctx, "/v1/keys", {
+      includeRevoked: options.includeRevoked
+    });
+    return result.data;
+  }
+  /**
+   * Create a new API key
+   *
+   * @example
+   * ```ts
+   * const newKey = await client.keys.create({
+   *   name: "Production Key",
+   *   scopes: ["scrape", "crawl", "status", "data:read"],
+   *   expiresInDays: 365
+   * });
+   *
+   * // IMPORTANT: Save this key immediately - it won't be shown again!
+   * console.log(newKey.key);
+   * ```
+   */
+  async create(options) {
+    const result = await post(this.ctx, "/v1/keys", {
+      name: options.name,
+      scopes: options.scopes,
+      expiresInDays: options.expiresInDays,
+      ipAllowlist: options.ipAllowlist
+    });
+    return result.data;
+  }
+  /**
+   * Get details of a specific key
+   *
+   * @example
+   * ```ts
+   * const key = await client.keys.get("key_abc123");
+   * console.log(key.scopes);
+   * console.log(key.lastUsedAt);
+   * ```
+   */
+  async get(keyId) {
+    const result = await get(this.ctx, `/v1/keys/${keyId}`);
+    return result.data;
+  }
+  /**
+   * Get usage statistics for a key
+   *
+   * @example
+   * ```ts
+   * const stats = await client.keys.getStats("key_abc123", { days: 30 });
+   * console.log(stats.stats.totalRequests);
+   * console.log(stats.stats.byEndpoint);
+   * ```
+   */
+  async getStats(keyId, options = {}) {
+    const result = await get(
+      this.ctx,
+      `/v1/keys/${keyId}/stats`,
+      {
+        days: options.days
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Rotate an API key (revoke old, create new)
+   *
+   * @example
+   * ```ts
+   * const rotated = await client.keys.rotate("key_abc123", {
+   *   newName: "Production Key v2"
+   * });
+   *
+   * // Old key is now invalid
+   * console.log(rotated.oldKeyRevoked); // true
+   *
+   * // Save new key immediately!
+   * console.log(rotated.newKey.key);
+   * ```
+   */
+  async rotate(keyId, options = {}) {
+    const result = await post(
+      this.ctx,
+      `/v1/keys/${keyId}/rotate`,
+      {
+        newName: options.newName
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Revoke (delete) an API key
+   *
+   * @example
+   * ```ts
+   * await client.keys.revoke("key_abc123");
+   * ```
+   */
+  async revoke(keyId) {
+    const result = await del(this.ctx, `/v1/keys/${keyId}`);
+    return result.data;
+  }
+  /**
+   * Revoke all API keys (except the current one)
+   *
+   * @example
+   * ```ts
+   * // Use with caution!
+   * const result = await client.keys.revokeAll();
+   * console.log(`Revoked ${result.count} keys`);
+   * ```
+   */
+  async revokeAll() {
+    const result = await del(
+      this.ctx,
+      "/v1/keys/all"
+    );
+    return result.data;
+  }
+  /**
+   * Get active keys only
+   *
+   * @example
+   * ```ts
+   * const activeKeys = await client.keys.getActive();
+   * ```
+   */
+  async getActive() {
+    const all = await this.list({ includeRevoked: false });
+    return all.keys.filter((k) => k.isActive);
+  }
+  /**
+   * Check if a key is valid (active and not expired)
+   *
+   * @example
+   * ```ts
+   * const isValid = await client.keys.isValid("key_abc123");
+   * ```
+   */
+  async isValid(keyId) {
+    try {
+      const key = await this.get(keyId);
+      if (!key.isActive) return false;
+      if (key.expiresAt && new Date(key.expiresAt) < /* @__PURE__ */ new Date()) return false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/resources/scrape.ts
+var ScrapeResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Create a new scrape job
+   *
+   * @example
+   * ```ts
+   * const job = await client.scrape.create({
+   *   url: "https://example.com/product",
+   *   extractDeal: true,
+   *   screenshot: { enabled: true, format: "webp" }
+   * });
+   * console.log(job.jobId);
+   * ```
+   */
+  async create(options) {
+    const body = {
+      url: options.url,
+      detectSignals: options.detectSignals ?? true,
+      extractWithAI: options.extractWithAI,
+      extractDeal: options.extractDeal,
+      useAdvancedModel: options.useAdvancedModel,
+      minDealScore: options.minDealScore,
+      screenshot: options.screenshot,
+      excludeTags: options.excludeTags,
+      excludeSelectors: options.excludeSelectors,
+      onlyMainContent: options.onlyMainContent,
+      headers: options.headers,
+      timeout: options.timeout
+    };
+    const result = await post(this.ctx, "/v1/scrape", body);
+    return result.data;
+  }
+  /**
+   * Scrape a URL with deal extraction enabled
+   * Convenience method for common use case
+   *
+   * @example
+   * ```ts
+   * const job = await client.scrape.extractDeal("https://example.com/sale");
+   * ```
+   */
+  async extractDeal(url, options) {
+    return this.create({
+      url,
+      extractDeal: true,
+      ...options
+    });
+  }
+  /**
+   * Scrape a URL with screenshot capture
+   * Convenience method for screenshot capture
+   *
+   * @example
+   * ```ts
+   * const job = await client.scrape.withScreenshot("https://example.com", {
+   *   format: "webp",
+   *   fullPage: true
+   * });
+   * ```
+   */
+  async withScreenshot(url, screenshotOptions, options) {
+    return this.create({
+      url,
+      screenshot: {
+        enabled: true,
+        ...screenshotOptions
+      },
+      ...options
+    });
+  }
+};
+
+// src/resources/status.ts
+var StatusResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Get the status of a job
+   *
+   * @example
+   * ```ts
+   * const status = await client.status.get("job_abc123");
+   * console.log(status.status); // "completed"
+   * console.log(status.result);
+   * ```
+   */
+  async get(jobId) {
+    const result = await get(
+      this.ctx,
+      `/v1/status/${jobId}`
+    );
+    return result.data;
+  }
+  /**
+   * Get deals found by a job
+   *
+   * @example
+   * ```ts
+   * const deals = await client.status.getDeals("job_abc123", {
+   *   minScore: 70,
+   *   limit: 20
+   * });
+   * console.log(deals.deals);
+   * ```
+   */
+  async getDeals(jobId, options) {
+    const result = await get(
+      this.ctx,
+      `/v1/status/${jobId}/deals`,
+      {
+        minScore: options?.minScore,
+        limit: options?.limit
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Resume a paused or failed job from checkpoint
+   *
+   * @example
+   * ```ts
+   * const resumed = await client.status.resume("job_abc123");
+   * console.log(resumed.newJobId);
+   * ```
+   */
+  async resume(jobId) {
+    const result = await post(
+      this.ctx,
+      `/v1/status/${jobId}/resume`
+    );
+    return result.data;
+  }
+  /**
+   * Get detailed metrics for a job
+   *
+   * @example
+   * ```ts
+   * const metrics = await client.status.getMetrics("job_abc123");
+   * console.log(metrics.metrics.successRate);
+   * ```
+   */
+  async getMetrics(jobId) {
+    const result = await get(
+      this.ctx,
+      `/v1/status/${jobId}/metrics`
+    );
+    return result.data;
+  }
+  /**
+   * Cancel a pending or active job
+   *
+   * @example
+   * ```ts
+   * const cancelled = await client.status.cancel("job_abc123");
+   * console.log(cancelled.success);
+   * ```
+   */
+  async cancel(jobId) {
+    const result = await del(
+      this.ctx,
+      `/v1/status/${jobId}`
+    );
+    return result.data;
+  }
+  /**
+   * Check if a job is complete
+   * Convenience method for polling
+   *
+   * @example
+   * ```ts
+   * const isComplete = await client.status.isComplete("job_abc123");
+   * ```
+   */
+  async isComplete(jobId) {
+    const status = await this.get(jobId);
+    return status.status === "completed" || status.status === "failed";
+  }
+  /**
+   * Check if a job succeeded
+   * Convenience method for result checking
+   *
+   * @example
+   * ```ts
+   * const succeeded = await client.status.succeeded("job_abc123");
+   * ```
+   */
+  async succeeded(jobId) {
+    const status = await this.get(jobId);
+    return status.status === "completed";
+  }
+  /**
+   * Get the result of a completed job
+   * Throws if job is not complete
+   *
+   * @example
+   * ```ts
+   * const result = await client.status.getResult("job_abc123");
+   * ```
+   */
+  async getResult(jobId) {
+    const status = await this.get(jobId);
+    if (status.status === "failed") {
+      throw new Error(`Job failed: ${status.error || "Unknown error"}`);
+    }
+    if (status.status !== "completed") {
+      throw new Error(`Job not complete. Status: ${status.status}`);
+    }
+    return status.result;
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Create a new webhook
+   *
+   * @example
+   * ```ts
+   * const webhook = await client.webhooks.create({
+   *   event: "deal.found",
+   *   url: "https://my-server.com/webhooks/deals",
+   *   secret: "my-webhook-secret",
+   *   minDealScore: 70
+   * });
+   * console.log(webhook.webhookId);
+   * ```
+   */
+  async create(options) {
+    const result = await post(this.ctx, "/v1/webhooks", {
+      event: options.event,
+      url: options.url,
+      secret: options.secret,
+      minDealScore: options.minDealScore,
+      categories: options.categories,
+      active: options.active
+    });
+    return result.data;
+  }
+  /**
+   * List all webhooks
+   *
+   * @example
+   * ```ts
+   * const webhooks = await client.webhooks.list();
+   * webhooks.webhooks.forEach(w => {
+   *   console.log(w.event, w.url, w.active);
+   * });
+   * ```
+   */
+  async list() {
+    const result = await get(this.ctx, "/v1/webhooks");
+    return result.data;
+  }
+  /**
+   * Get a webhook by ID
+   *
+   * @example
+   * ```ts
+   * const webhook = await client.webhooks.get("webhook_abc123");
+   * console.log(webhook.event);
+   * ```
+   */
+  async get(webhookId) {
+    const result = await get(
+      this.ctx,
+      `/v1/webhooks/${webhookId}`
+    );
+    return result.data;
+  }
+  /**
+   * Update a webhook
+   *
+   * @example
+   * ```ts
+   * const updated = await client.webhooks.update("webhook_abc123", {
+   *   minDealScore: 80,
+   *   active: false
+   * });
+   * ```
+   */
+  async update(webhookId, options) {
+    const result = await patch(
+      this.ctx,
+      `/v1/webhooks/${webhookId}`,
+      {
+        url: options.url,
+        secret: options.secret,
+        minDealScore: options.minDealScore,
+        categories: options.categories,
+        active: options.active
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Delete a webhook
+   *
+   * @example
+   * ```ts
+   * await client.webhooks.delete("webhook_abc123");
+   * ```
+   */
+  async delete(webhookId) {
+    const result = await del(
+      this.ctx,
+      `/v1/webhooks/${webhookId}`
+    );
+    return result.data;
+  }
+  /**
+   * Test a webhook by sending a test payload
+   *
+   * @example
+   * ```ts
+   * const result = await client.webhooks.test("webhook_abc123");
+   * if (result.delivered) {
+   *   console.log(`Delivered in ${result.responseTime}ms`);
+   * } else {
+   *   console.log(`Failed: ${result.error}`);
+   * }
+   * ```
+   */
+  async test(webhookId) {
+    const result = await post(
+      this.ctx,
+      `/v1/webhooks/${webhookId}/test`
+    );
+    return result.data;
+  }
+  /**
+   * Enable a webhook
+   * Convenience method for activating a webhook
+   *
+   * @example
+   * ```ts
+   * await client.webhooks.enable("webhook_abc123");
+   * ```
+   */
+  async enable(webhookId) {
+    return this.update(webhookId, { active: true });
+  }
+  /**
+   * Disable a webhook
+   * Convenience method for deactivating a webhook
+   *
+   * @example
+   * ```ts
+   * await client.webhooks.disable("webhook_abc123");
+   * ```
+   */
+  async disable(webhookId) {
+    return this.update(webhookId, { active: false });
+  }
+  /**
+   * Get active webhooks only
+   *
+   * @example
+   * ```ts
+   * const active = await client.webhooks.getActive();
+   * ```
+   */
+  async getActive() {
+    const all = await this.list();
+    return all.webhooks.filter((w) => w.active);
+  }
+  /**
+   * Get webhooks by event type
+   *
+   * @example
+   * ```ts
+   * const dealWebhooks = await client.webhooks.getByEvent("deal.found");
+   * ```
+   */
+  async getByEvent(event) {
+    const all = await this.list();
+    return all.webhooks.filter((w) => w.event === event);
+  }
+};
+
+// src/client.ts
+var DealCrawl = class {
+  /** Internal request context */
+  ctx;
+  // ============================================
+  // RESOURCES
+  // ============================================
+  /**
+   * Scrape resource - Single page scraping
+   *
+   * @example
+   * ```ts
+   * const job = await client.scrape.create({
+   *   url: "https://example.com",
+   *   extractDeal: true
+   * });
+   * ```
+   */
+  scrape;
+  /**
+   * Crawl resource - Website crawling
+   *
+   * @example
+   * ```ts
+   * const job = await client.crawl.create({
+   *   url: "https://shop.example.com",
+   *   maxPages: 100
+   * });
+   *
+   * // With template
+   * const job = await client.crawl.withTemplate("ecommerce", {
+   *   url: "https://shop.example.com"
+   * });
+   * ```
+   */
+  crawl;
+  /**
+   * Extract resource - LLM-based structured data extraction
+   *
+   * @example
+   * ```ts
+   * const job = await client.extract.create({
+   *   url: "https://example.com/product",
+   *   schema: { type: "object", properties: {...} }
+   * });
+   * ```
+   */
+  extract;
+  /**
+   * Dork resource - Google Dork searches
+   *
+   * @example
+   * ```ts
+   * const job = await client.dork.create({
+   *   query: "discount coupon",
+   *   site: "amazon.com"
+   * });
+   * ```
+   */
+  dork;
+  /**
+   * Status resource - Job status management
+   *
+   * @example
+   * ```ts
+   * const status = await client.status.get(jobId);
+   * const deals = await client.status.getDeals(jobId);
+   * await client.status.cancel(jobId);
+   * ```
+   */
+  status;
+  /**
+   * Data resource - Jobs and deals data access
+   *
+   * @example
+   * ```ts
+   * const jobs = await client.data.listJobs();
+   * const deals = await client.data.listDeals({ minScore: 70 });
+   * const stats = await client.data.getStats();
+   * ```
+   */
+  data;
+  /**
+   * Webhooks resource - Webhook management
+   *
+   * @example
+   * ```ts
+   * await client.webhooks.create({
+   *   event: "deal.found",
+   *   url: "https://..."
+   * });
+   * ```
+   */
+  webhooks;
+  /**
+   * Keys resource - API key management
+   *
+   * @example
+   * ```ts
+   * const newKey = await client.keys.create({
+   *   name: "Production",
+   *   scopes: ["scrape", "status"]
+   * });
+   * ```
+   */
+  keys;
+  /**
+   * Account resource - Account info and preferences
+   *
+   * @example
+   * ```ts
+   * const account = await client.account.get();
+   * await client.account.updatePreferences({
+   *   minDealScore: 70
+   * });
+   * ```
+   */
+  account;
+  // ============================================
+  // CONSTRUCTOR
+  // ============================================
+  /**
+   * Create a new DealCrawl client
+   *
+   * @param config - Client configuration
+   *
+   * @example
+   * ```ts
+   * // Minimal config
+   * const client = new DealCrawl({ apiKey: "sk_xxx" });
+   *
+   * // Full config
+   * const client = new DealCrawl({
+   *   apiKey: "sk_xxx",
+   *   baseUrl: "https://api.dealcrawl.dev",
+   *   timeout: 30000,
+   *   maxRetries: 3,
+   *   retryDelay: 1000,
+   *   onRateLimit: (info) => console.log("Rate limited!", info)
+   * });
+   * ```
+   */
+  constructor(config) {
+    if (!config.apiKey || !config.apiKey.trim()) {
+      throw new Error("API key is required");
+    }
+    this.ctx = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULT_CONFIG.baseUrl,
+      timeout: config.timeout ?? DEFAULT_CONFIG.timeout,
+      maxRetries: config.maxRetries ?? DEFAULT_CONFIG.maxRetries,
+      retryDelay: config.retryDelay ?? DEFAULT_CONFIG.retryDelay,
+      onRateLimit: config.onRateLimit
+    };
+    this.scrape = new ScrapeResource(this.ctx);
+    this.crawl = new CrawlResource(this.ctx);
+    this.extract = new ExtractResource(this.ctx);
+    this.dork = new DorkResource(this.ctx);
+    this.status = new StatusResource(this.ctx);
+    this.data = new DataResource(this.ctx);
+    this.webhooks = new WebhooksResource(this.ctx);
+    this.keys = new KeysResource(this.ctx);
+    this.account = new AccountResource(this.ctx);
+  }
+  // ============================================
+  // POLLING METHODS
+  // ============================================
+  /**
+   * Wait for a job to complete
+   * Polls the status endpoint until the job finishes
+   *
+   * @example
+   * ```ts
+   * const job = await client.scrape.create({ url: "..." });
+   *
+   * // Simple wait
+   * const result = await client.waitForResult(job.jobId);
+   *
+   * // With options
+   * const result = await client.waitForResult(job.jobId, {
+   *   pollInterval: 1000,
+   *   timeout: 60000,
+   *   onProgress: (status) => console.log(status.progress)
+   * });
+   * ```
+   */
+  async waitForResult(jobId, options) {
+    return waitForResult(this.ctx, jobId, options);
+  }
+  /**
+   * Wait for multiple jobs to complete
+   * Returns when all jobs are done
+   *
+   * @example
+   * ```ts
+   * const jobs = await Promise.all([
+   *   client.scrape.create({ url: "url1" }),
+   *   client.scrape.create({ url: "url2" }),
+   * ]);
+   *
+   * const results = await client.waitForAll(jobs.map(j => j.jobId));
+   * ```
+   */
+  async waitForAll(jobIds, options) {
+    return waitForAll(this.ctx, jobIds, options);
+  }
+  /**
+   * Wait for any job to complete
+   * Returns as soon as one job finishes
+   *
+   * @example
+   * ```ts
+   * const jobIds = ["job1", "job2", "job3"];
+   * const firstResult = await client.waitForAny(jobIds);
+   * ```
+   */
+  async waitForAny(jobIds, options) {
+    return waitForAny(this.ctx, jobIds, options);
+  }
+  // ============================================
+  // CONVENIENCE METHODS
+  // ============================================
+  /**
+   * Scrape a URL and wait for result
+   * Combines create and waitForResult
+   *
+   * @example
+   * ```ts
+   * const result = await client.scrapeAndWait({
+   *   url: "https://example.com",
+   *   extractDeal: true
+   * });
+   * ```
+   */
+  async scrapeAndWait(options, waitOptions) {
+    const job = await this.scrape.create(options);
+    return this.waitForResult(job.jobId, waitOptions);
+  }
+  /**
+   * Crawl a URL and wait for result
+   * Combines create and waitForResult
+   *
+   * @example
+   * ```ts
+   * const result = await client.crawlAndWait({
+   *   url: "https://shop.example.com",
+   *   maxPages: 50
+   * });
+   * ```
+   */
+  async crawlAndWait(options, waitOptions) {
+    const job = await this.crawl.create(options);
+    return this.waitForResult(job.jobId, waitOptions);
+  }
+  /**
+   * Extract data and wait for result
+   * Combines create and waitForResult
+   *
+   * @example
+   * ```ts
+   * const result = await client.extractAndWait({
+   *   url: "https://example.com/product",
+   *   schema: { type: "object", properties: {...} }
+   * });
+   * ```
+   */
+  async extractAndWait(options, waitOptions) {
+    const job = await this.extract.create(options);
+    return this.waitForResult(job.jobId, waitOptions);
+  }
+};
+
+export { AccountResource, CrawlResource, DEFAULT_CONFIG, DataResource, DealCrawl, DealCrawlError, DorkResource, ERROR_CODES, ExtractResource, KeysResource, ScrapeResource, StatusResource, WebhooksResource, DealCrawl as default, pollUntil, waitForAll, waitForAny, waitForResult };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map