zenrows 2.0.2 → 2.0.3

package/dist/index.js

@@ -41,10 +41,11 @@ var package_default = {
     "@biomejs/biome": "1.8.1",
     "@types/async-retry": "^1.4.9",
     "@types/node": "^20.19.39",
+    "@vitest/coverage-v8": "1.6.1",
     msw: "^2.13.4",
     tsup: "^8.5.1",
     typescript: "^5.9.3",
-    vitest: "^1.6.1"
+    vitest: "^3.2.6"
   },
   dependencies: {
     fastq: "^1.20.1",
@@ -52,16 +53,1283 @@ var package_default = {
   }
 };
 
+// src/batch/download.ts
+import { createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var DEFAULT_MAX_FILES = 1e5;
+var DEFAULT_MAX_BYTES_PER_FILE = 50 * 1024 * 1024;
+var DEFAULT_MAX_COUNT_IN_MEMORY = 1e4;
+var DEFAULT_MAX_TOTAL_BYTES_IN_MEMORY = 500 * 1024 * 1024;
+async function fetchResultBody(task, maxBytes) {
+  if (!task.result_url) {
+    throw new Error(`task ${task.task_id} has no result_url (not a successful task?)`);
+  }
+  const response = await fetch(task.result_url);
+  if (!response.ok) {
+    throw new Error(`downloading task ${task.task_id} failed with status ${response.status}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (maxBytes !== void 0 && buffer.byteLength > maxBytes) {
+    throw new Error(
+      `task ${task.task_id}'s body (${buffer.byteLength} bytes) exceeds maxBytesPerFile (${maxBytes})`
+    );
+  }
+  return buffer;
+}
+async function runPool(items, concurrency, worker) {
+  let cursor = 0;
+  const errors = [];
+  async function next() {
+    while (cursor < items.length) {
+      const index = cursor++;
+      try {
+        await worker(items[index], index);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.max(1, concurrency) }, () => next());
+  await Promise.all(workers);
+  if (errors.length) {
+    throw errors[0];
+  }
+}
+function defaultFileName(task, useExternalId) {
+  const base = useExternalId && task.external_id ? task.external_id : task.task_id;
+  return base.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+async function downloadToDir(results, targetDir, {
+  nameFn,
+  useExternalId = false,
+  concurrency = 1,
+  maxFiles = DEFAULT_MAX_FILES,
+  maxBytesPerFile = DEFAULT_MAX_BYTES_PER_FILE
+} = {}) {
+  await mkdir(targetDir, { recursive: true });
+  const tasks = [];
+  for await (const task of results) {
+    tasks.push(task);
+    if (tasks.length > maxFiles) {
+      throw new Error(`result count exceeds maxFiles (${maxFiles})`);
+    }
+  }
+  await runPool(tasks, concurrency, async (task) => {
+    const body = await fetchResultBody(task, maxBytesPerFile);
+    const fileName = nameFn ? nameFn(task) : defaultFileName(task, useExternalId);
+    const filePath = join(targetDir, fileName);
+    await mkdir(dirname(filePath), { recursive: true });
+    await pipeline(Readable.from(body), createWriteStream(filePath));
+  });
+  return tasks.length;
+}
+async function downloadToMemory(results, {
+  concurrency = 1,
+  maxCount = DEFAULT_MAX_COUNT_IN_MEMORY,
+  maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES_IN_MEMORY,
+  maxBytesPerFile = DEFAULT_MAX_BYTES_PER_FILE
+} = {}) {
+  const tasks = [];
+  for await (const task of results) {
+    tasks.push(task);
+    if (tasks.length > maxCount) {
+      throw new Error(`result count exceeds maxCount (${maxCount})`);
+    }
+  }
+  const downloaded = new Array(tasks.length);
+  let totalBytes = 0;
+  await runPool(tasks, concurrency, async (task, index) => {
+    const body = await fetchResultBody(task, maxBytesPerFile);
+    totalBytes += body.byteLength;
+    if (totalBytes > maxTotalBytes) {
+      throw new Error(`total downloaded bytes exceeds maxTotalBytes (${maxTotalBytes})`);
+    }
+    downloaded[index] = { taskId: task.task_id, externalId: task.external_id, url: task.url, body };
+  });
+  return downloaded;
+}
+async function downloadTaskToFile(task, target) {
+  const body = await fetchResultBody(task);
+  await mkdir(dirname(target), { recursive: true });
+  await pipeline(Readable.from(body), createWriteStream(target));
+}
+async function downloadTaskToMemory(task) {
+  return fetchResultBody(task);
+}
+
+// src/batch/errors.ts
+var ZenRowsBatchError = class extends Error {
+  status;
+  problem;
+  code;
+  extras;
+  constructor(status, problem, extras) {
+    const message = problem ? `${status} ${problem.title ?? "Error"}: ${problem.detail ?? problem.code ?? "unknown"}` : `${status} (no problem body)`;
+    super(message);
+    this.name = "ZenRowsBatchError";
+    this.status = status;
+    this.problem = problem;
+    this.code = problem?.code ?? "internal";
+    this.extras = extras;
+  }
+};
+var PROBLEM_STANDARD_KEYS = /* @__PURE__ */ new Set(["type", "title", "status", "code", "detail", "instance"]);
+async function parseProblem(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { problem: void 0, extras: void 0 };
+  }
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    return { problem: void 0, extras: void 0 };
+  }
+  const record = body;
+  const extras = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (!PROBLEM_STANDARD_KEYS.has(key)) {
+      extras[key] = value;
+    }
+  }
+  const problem = {
+    type: typeof record.type === "string" ? record.type : "about:blank",
+    title: typeof record.title === "string" ? record.title : "Error",
+    status: typeof record.status === "number" ? record.status : response.status,
+    code: typeof record.code === "string" ? record.code : "internal",
+    detail: typeof record.detail === "string" ? record.detail : void 0,
+    instance: typeof record.instance === "string" ? record.instance : void 0
+  };
+  return { problem, extras: Object.keys(extras).length ? extras : void 0 };
+}
+
+// src/batch/estimate.ts
+var BASE_CREDITS = 1;
+var JS_CREDITS = 5;
+var PREMIUM_PROXY_CREDITS = 10;
+var JS_AND_PROXY_CREDITS = 25;
+var AUTO_MIN_CREDITS = 1;
+var AUTO_MAX_CREDITS = 25;
+var TIER_ORDER = [
+  "base",
+  "js_render",
+  "premium_proxy",
+  "js_render+premium_proxy",
+  "auto"
+];
+var TRUTHY_STRINGS = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
+function truthy(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") return TRUTHY_STRINGS.has(value.trim().toLowerCase());
+  return false;
+}
+function isAuto(params) {
+  return String(params.mode ?? "").trim().toLowerCase() === "auto";
+}
+function costForParams(params) {
+  if (isAuto(params)) {
+    return { tier: "auto", min: AUTO_MIN_CREDITS, max: AUTO_MAX_CREDITS };
+  }
+  const js = truthy(params.js_render);
+  const px = truthy(params.premium_proxy);
+  if (js && px) {
+    return {
+      tier: "js_render+premium_proxy",
+      min: JS_AND_PROXY_CREDITS,
+      max: JS_AND_PROXY_CREDITS
+    };
+  }
+  if (px) {
+    return { tier: "premium_proxy", min: PREMIUM_PROXY_CREDITS, max: PREMIUM_PROXY_CREDITS };
+  }
+  if (js) {
+    return { tier: "js_render", min: JS_CREDITS, max: JS_CREDITS };
+  }
+  return { tier: "base", min: BASE_CREDITS, max: BASE_CREDITS };
+}
+function taskParams(task) {
+  if (typeof task === "string") return {};
+  const record = task;
+  return record.zenrows_params ?? {};
+}
+function estimateCost(tasks, zenrowsParams) {
+  const jobParams = zenrowsParams ?? {};
+  const agg = /* @__PURE__ */ new Map();
+  let totalMin = 0;
+  let totalMax = 0;
+  let count = 0;
+  for (const task of tasks) {
+    count += 1;
+    const merged = { ...jobParams, ...taskParams(task) };
+    const cost = costForParams(merged);
+    totalMin += cost.min;
+    totalMax += cost.max;
+    const existing = agg.get(cost.tier);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      agg.set(cost.tier, { count: 1, min: cost.min, max: cost.max });
+    }
+  }
+  const breakdown = TIER_ORDER.filter((tier) => agg.has(tier)).map((tier) => {
+    const entry = agg.get(tier);
+    if (!entry) throw new Error("unreachable");
+    return { tier, count: entry.count, unitMin: entry.min, unitMax: entry.max };
+  });
+  return {
+    taskCount: count,
+    min: totalMin,
+    max: totalMax,
+    breakdown,
+    exact: totalMin === totalMax
+  };
+}
+
+// src/batch/resources.ts
+var RunRef = class {
+  constructor(client, jobId, runId) {
+    this.jobId = jobId;
+    this.runId = runId;
+    this.#client = client;
+  }
+  jobId;
+  runId;
+  #client;
+  async load() {
+    return new RunHandle(
+      this.#client,
+      this.jobId,
+      this.runId,
+      await this.#client._getRunData(this.jobId, this.runId)
+    );
+  }
+  async delete() {
+    await this.#client._deleteRun(this.jobId, this.runId);
+  }
+  results(options = {}) {
+    return this.#client.iterResults(this.jobId, { runId: this.runId, status: options.status });
+  }
+  taskHistory(taskId) {
+    return this.#client.getTaskHistory(this.jobId, taskId, { runId: this.runId });
+  }
+  downloadToDir(targetDir, options = {}) {
+    return this.#client.downloadToDir(this.jobId, this.runId, targetDir, {
+      status: "successful",
+      ...options
+    });
+  }
+  downloadToMemory(options = {}) {
+    return this.#client.downloadToMemory(this.jobId, this.runId, {
+      status: "successful",
+      ...options
+    });
+  }
+  downloadTaskToFile(task, target) {
+    return this.#client.downloadTaskToFile(task, target);
+  }
+  downloadTaskToMemory(task) {
+    return this.#client.downloadTaskToMemory(task);
+  }
+  async wait(options = {}) {
+    const run = await this.#client.waitForRun(this.jobId, { ...options, runId: this.runId });
+    return new RunHandle(this.#client, this.jobId, this.runId, run);
+  }
+  startExport() {
+    return this.#client.startResultsExport(this.jobId, this.runId);
+  }
+  export(exportId) {
+    return new ExportRef(this.#client, this.jobId, this.runId, exportId);
+  }
+  downloadAllResults(targetPath, options = {}) {
+    return this.#client.downloadAllResults(this.jobId, this.runId, targetPath, options);
+  }
+};
+var RunHandle = class extends RunRef {
+  constructor(client, jobId, runId, data) {
+    super(client, jobId, runId);
+    this.data = data;
+  }
+  data;
+  get status() {
+    return this.data.status;
+  }
+  get stats() {
+    return this.data.stats;
+  }
+};
+var ExportRef = class {
+  constructor(client, jobId, runId, exportId, startResponse) {
+    this.jobId = jobId;
+    this.runId = runId;
+    this.exportId = exportId;
+    this.startResponse = startResponse;
+    this.#client = client;
+  }
+  jobId;
+  runId;
+  exportId;
+  startResponse;
+  #client;
+  async load() {
+    const data = await this.#client._getExport(this.jobId, this.runId, this.exportId);
+    return new ExportHandle(
+      this.#client,
+      this.jobId,
+      this.runId,
+      this.exportId,
+      data,
+      this.startResponse
+    );
+  }
+  async wait(options = {}) {
+    const data = await this.#client.waitForExport(this.jobId, this.runId, this.exportId, options);
+    return new ExportHandle(
+      this.#client,
+      this.jobId,
+      this.runId,
+      this.exportId,
+      data,
+      this.startResponse
+    );
+  }
+  /** Stream the export zip to `targetPath`. The export must already be `completed`. */
+  async downloadToPath(targetPath) {
+    const handle = await this.load();
+    if (handle.data.status !== "completed" || !handle.data.download_url) {
+      throw new Error(handle.data.error ?? "export not completed");
+    }
+    const { mkdir: mkdir2 } = await import("fs/promises");
+    const { dirname: dirname2 } = await import("path");
+    const { createWriteStream: createWriteStream2 } = await import("fs");
+    const { Readable: Readable2 } = await import("stream");
+    const { pipeline: pipeline2 } = await import("stream/promises");
+    await mkdir2(dirname2(targetPath), { recursive: true });
+    const response = await fetch(handle.data.download_url);
+    if (!response.ok) {
+      throw new Error(`export download failed with status ${response.status}`);
+    }
+    await pipeline2(Readable2.fromWeb(response.body), createWriteStream2(targetPath));
+    return targetPath;
+  }
+};
+var ExportHandle = class extends ExportRef {
+  constructor(client, jobId, runId, exportId, data, startResponse) {
+    super(client, jobId, runId, exportId, startResponse);
+    this.data = data;
+  }
+  data;
+  get status() {
+    return this.data.status;
+  }
+};
+var CurrentRun = class {
+  constructor(client, jobId) {
+    this.jobId = jobId;
+    this.#client = client;
+  }
+  jobId;
+  #client;
+  async currentRunId() {
+    const job = await this.#client._getJobData(this.jobId);
+    if (!job.latest_run) {
+      throw new Error(`job ${this.jobId} has no run yet`);
+    }
+    return job.latest_run.run_id;
+  }
+  async load() {
+    const job = await this.#client._getJobData(this.jobId);
+    if (!job.latest_run) {
+      throw new Error(`job ${this.jobId} has no run yet`);
+    }
+    return new RunHandle(this.#client, this.jobId, job.latest_run.run_id, job.latest_run);
+  }
+  async pause() {
+    const run = await this.#client._postPause(this.jobId);
+    return new RunHandle(this.#client, this.jobId, run.run_id, run);
+  }
+  async resume() {
+    const run = await this.#client._postResume(this.jobId);
+    return new RunHandle(this.#client, this.jobId, run.run_id, run);
+  }
+  async stop() {
+    const run = await this.#client._postStop(this.jobId);
+    return new RunHandle(this.#client, this.jobId, run.run_id, run);
+  }
+  cancel() {
+    return this.stop();
+  }
+  async wait(options = {}) {
+    const run = await this.#client.waitForRun(this.jobId, options);
+    return new RunHandle(this.#client, this.jobId, run.run_id, run);
+  }
+  results(options = {}) {
+    return this.#client.iterResults(this.jobId, { status: options.status });
+  }
+  taskHistory(taskId) {
+    return this.#client.getTaskHistory(this.jobId, taskId);
+  }
+  downloadToDir(targetDir, options = {}) {
+    return this.#client.downloadToDir(this.jobId, void 0, targetDir, {
+      status: "successful",
+      ...options
+    });
+  }
+  downloadToMemory(options = {}) {
+    return this.#client.downloadToMemory(this.jobId, void 0, {
+      status: "successful",
+      ...options
+    });
+  }
+  downloadTaskToFile(task, target) {
+    return this.#client.downloadTaskToFile(task, target);
+  }
+  downloadTaskToMemory(task) {
+    return this.#client.downloadTaskToMemory(task);
+  }
+  async startExport() {
+    return this.#client.startResultsExport(this.jobId, await this.currentRunId());
+  }
+  async downloadAllResults(targetPath, options = {}) {
+    return this.#client.downloadAllResults(
+      this.jobId,
+      await this.currentRunId(),
+      targetPath,
+      options
+    );
+  }
+};
+var ScheduleControls = class {
+  constructor(client, jobId) {
+    this.jobId = jobId;
+    this.#client = client;
+  }
+  jobId;
+  #client;
+  async pause() {
+    return new JobHandle(
+      this.#client,
+      this.jobId,
+      await this.#client._postScheduleState(this.jobId, "paused")
+    );
+  }
+  async resume() {
+    return new JobHandle(
+      this.#client,
+      this.jobId,
+      await this.#client._postScheduleState(this.jobId, "active")
+    );
+  }
+  async update(schedule) {
+    return new JobHandle(
+      this.#client,
+      this.jobId,
+      await this.#client._putSchedule(this.jobId, schedule.toRequestBody())
+    );
+  }
+};
+var JobRef = class {
+  constructor(client, jobId, submitResponse) {
+    this.jobId = jobId;
+    this.submitResponse = submitResponse;
+    this.#client = client;
+  }
+  jobId;
+  submitResponse;
+  #client;
+  runFacet;
+  scheduleFacet;
+  /** Operations on the CURRENT run — pause/resume/stop/wait/results/downloads/startExport. */
+  get run() {
+    if (!this.runFacet) this.runFacet = new CurrentRun(this.#client, this.jobId);
+    return this.runFacet;
+  }
+  /** Operations on the schedule — pause/resume/update (scheduled jobs only). */
+  get schedule() {
+    if (!this.scheduleFacet) this.scheduleFacet = new ScheduleControls(this.#client, this.jobId);
+    return this.scheduleFacet;
+  }
+  /** The job status from the submit response — only known on refs from a `submit*` call. */
+  get status() {
+    return this.submitResponse?.status;
+  }
+  get acceptedTasks() {
+    return this.submitResponse?.accepted_tasks;
+  }
+  async load() {
+    return new JobHandle(this.#client, this.jobId, await this.#client._getJobData(this.jobId));
+  }
+  async close() {
+    return new JobHandle(this.#client, this.jobId, await this.#client._postClose(this.jobId));
+  }
+  async delete() {
+    await this.#client._delete(this.jobId);
+  }
+  async rerun(options = {}) {
+    const resp = await this.#client._postRerun(this.jobId, options);
+    return new RunHandle(this.#client, this.jobId, resp.latest_run.run_id, resp.latest_run);
+  }
+  /** Shortcut for `rerun({ status: "failed" })` (or `"failed,pending"` with `includePending`). */
+  retryFailed(options = {}) {
+    const status = options.includePending ? ["failed", "pending"] : "failed";
+    return this.rerun({ status, idempotencyKey: options.idempotencyKey });
+  }
+  addTasks(tasks, options = {}) {
+    return this.#client._postTasks(this.jobId, tasks, options);
+  }
+  async *runs(pageSize) {
+    yield* this.#client.iterRuns(this.jobId, pageSize);
+  }
+  addFileInput(data, options) {
+    return this.#client.uploadCsv(data, options);
+  }
+  getWebhook() {
+    return this.#client.getJobWebhook(this.jobId);
+  }
+  setWebhook(url, signature) {
+    return this.#client.putJobWebhook(this.jobId, { url, signature });
+  }
+  async deleteWebhook() {
+    await this.#client.deleteJobWebhook(this.jobId);
+  }
+  /** Block until the current run's async-carrier ingestion has finished writing task rows. */
+  async waitForIngest(options = {}) {
+    return new JobHandle(
+      this.#client,
+      this.jobId,
+      await this.#client._waitForIngestRaw(this.jobId, options),
+      this.submitResponse
+    );
+  }
+};
+var JobHandle = class extends JobRef {
+  constructor(client, jobId, data, submitResponse) {
+    super(client, jobId, submitResponse);
+    this.data = data;
+  }
+  data;
+  get status() {
+    return this.data.status;
+  }
+};
+
+// src/batch/transport.ts
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]);
+var BACKOFF_BASE_MS = 250;
+var BACKOFF_CAP_MS = 1e4;
+var DEFAULT_RETRIES = 3;
+function isIdempotent(method, hasIdempotencyKey) {
+  return IDEMPOTENT_METHODS.has(method.toUpperCase()) || method.toUpperCase() === "POST" && hasIdempotencyKey;
+}
+function backoffMs(attempt) {
+  const base = Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_CAP_MS);
+  return base * (1 + (Math.random() * 2 - 1) * 0.2);
+}
+function retryAfterMs(response) {
+  const raw = response.headers.get("Retry-After");
+  if (!raw) return void 0;
+  const secs = Number(raw);
+  if (Number.isNaN(secs) || secs < 0) return void 0;
+  return secs * 1e3;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var BatchTransport = class {
+  constructor(baseURL, apiKey, retries = DEFAULT_RETRIES) {
+    this.baseURL = baseURL;
+    this.apiKey = apiKey;
+    this.retries = retries;
+  }
+  baseURL;
+  apiKey;
+  retries;
+  /** Send a request, parse the response, throw `ZenRowsBatchError` on non-2xx. */
+  async requestJson(method, path, options = {}) {
+    const response = await this.send(method, path, options);
+    if (!response.ok) {
+      const { problem, extras } = await parseProblem(response);
+      throw new ZenRowsBatchError(response.status, problem, extras);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  /** Send a request and return the raw `Response` — used for endpoints that don't return JSON. */
+  async requestRaw(method, path, options = {}) {
+    const response = await this.send(method, path, options);
+    if (!response.ok) {
+      const { problem, extras } = await parseProblem(response);
+      throw new ZenRowsBatchError(response.status, problem, extras);
+    }
+    return response;
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseURL}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url;
+  }
+  async send(method, path, options) {
+    const url = this.buildUrl(path, options.query);
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "User-Agent": `zenrows/${package_default.version} node`,
+      ...options.headers
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (options.idempotencyKey) {
+      headers["Idempotency-Key"] = options.idempotencyKey;
+    }
+    const idempotent = isIdempotent(method, Boolean(options.idempotencyKey));
+    let attempt = 0;
+    while (true) {
+      let response;
+      try {
+        response = await fetch(url.toString(), {
+          method,
+          headers,
+          body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+        });
+      } catch (error) {
+        if (idempotent && attempt < this.retries) {
+          await sleep(backoffMs(attempt));
+          attempt += 1;
+          continue;
+        }
+        throw error;
+      }
+      if (idempotent && attempt < this.retries && RETRYABLE_STATUSES.has(response.status)) {
+        const wait = retryAfterMs(response) ?? backoffMs(attempt);
+        await sleep(wait);
+        attempt += 1;
+        continue;
+      }
+      return response;
+    }
+  }
+};
+
+// src/batch/waiters.ts
+var WaiterTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WaiterTimeoutError";
+  }
+};
+var WaiterFailureError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WaiterFailureError";
+  }
+};
+async function pollUntil(fetch2, {
+  isDone,
+  isFailure,
+  timeout = 300,
+  initialInterval = 1,
+  maxInterval = 15,
+  backoff = 1.5,
+  jitter = 0.2
+}) {
+  const deadline = Date.now() + timeout * 1e3;
+  let interval = initialInterval;
+  while (true) {
+    const value = await fetch2();
+    if (isDone(value)) {
+      return value;
+    }
+    if (isFailure?.(value)) {
+      throw new WaiterFailureError(
+        `waiter: resource entered failure state (${JSON.stringify(value)})`
+      );
+    }
+    const now = Date.now();
+    if (now >= deadline) {
+      throw new WaiterTimeoutError(`waiter: timed out after ${timeout}s waiting for target state`);
+    }
+    const remainingSeconds = (deadline - now) / 1e3;
+    const sleepSeconds = Math.min(interval, remainingSeconds) * (1 + jitter * (Math.random() * 2 - 1));
+    if (sleepSeconds > 0) {
+      await new Promise((resolve) => setTimeout(resolve, sleepSeconds * 1e3));
+    }
+    interval = Math.min(interval * backoff, maxInterval);
+  }
+}
+
+// src/batch/client.ts
+var DEFAULT_BATCH_API_URL = "https://async.api.zenrows.com/v1";
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "stopped", "deleted"]);
+var TERMINAL_EXPORT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed"]);
+function coerceUrl(item) {
+  return typeof item === "string" ? { url: item } : item;
+}
+var ZenRowsBatchClient = class {
+  apiKey;
+  transport;
+  constructor(apiKey, config = {}) {
+    this.apiKey = apiKey;
+    this.transport = new BatchTransport(
+      config.baseURL ?? DEFAULT_BATCH_API_URL,
+      apiKey,
+      config.retries
+    );
+  }
+  // ===== submit =====
+  async submitJob(options = {}) {
+    const { idempotencyKey, waitForIngest, ...body } = options;
+    const resp = await this.transport.requestJson("POST", "/jobs", { body, idempotencyKey });
+    const ref = new JobRef(this, resp.job_id, resp);
+    if (waitForIngest && resp.latest_run && resp.latest_run.ingest_status === "pending") {
+      return ref.waitForIngest();
+    }
+    return ref;
+  }
+  /** Submit a one-shot scraping job (closed, all tasks known upfront). */
+  async submitRegular(urls, fileInputId, opts = {}) {
+    if (urls !== void 0 && fileInputId !== void 0) {
+      throw new Error("submitRegular: pass urls OR fileInputId, not both.");
+    }
+    if (urls === void 0 && fileInputId === void 0) {
+      throw new Error(
+        "submitRegular: closed jobs require urls or fileInputId (use submitOpen for the open/extend pattern)."
+      );
+    }
+    return this.submitJob({
+      type: "regular",
+      status: "closed",
+      tasks: urls?.map(coerceUrl),
+      file_input_id: fileInputId,
+      zenrows_params: opts.zenrowsParams,
+      external_id: opts.externalId,
+      name: opts.name,
+      metadata: opts.metadata,
+      webhook: opts.webhook,
+      idempotencyKey: opts.idempotencyKey,
+      waitForIngest: opts.waitForIngest
+    });
+  }
+  /** Submit a streaming-style job that stays open for more tasks via `JobRef.addTasks`. */
+  submitOpen(urls, opts = {}) {
+    return this.submitJob({
+      type: "regular",
+      status: "open",
+      tasks: urls?.map(coerceUrl),
+      zenrows_params: opts.zenrowsParams,
+      external_id: opts.externalId,
+      name: opts.name,
+      metadata: opts.metadata,
+      webhook: opts.webhook,
+      idempotencyKey: opts.idempotencyKey,
+      waitForIngest: opts.waitForIngest
+    });
+  }
+  /** Submit a scheduled job. `schedule` is one of the `At`/`Rate`/`Calendar` builders. */
+  async submitScheduled(schedule, urls, fileInputId, opts = {}) {
+    if (urls !== void 0 && fileInputId !== void 0) {
+      throw new Error("submitScheduled: pass urls OR fileInputId, not both.");
+    }
+    return this.submitJob({
+      type: "scheduled",
+      status: "closed",
+      tasks: urls?.map(coerceUrl),
+      file_input_id: fileInputId,
+      zenrows_params: opts.zenrowsParams,
+      external_id: opts.externalId,
+      name: opts.name,
+      metadata: opts.metadata,
+      webhook: opts.webhook,
+      idempotencyKey: opts.idempotencyKey,
+      // biome-ignore lint/suspicious/noExplicitAny: schedule builder output matches JobSchedule at the wire boundary
+      ...{ schedule: schedule.toRequestBody() }
+    });
+  }
+  // ===== cost estimation (local, no API call) =====
+  estimateCost(tasks, zenrowsParams) {
+    return estimateCost(tasks, zenrowsParams);
+  }
+  // ===== jobs =====
+  /** A `JobRef` for an existing job with no network call — prefer this to act on a known id. */
+  job(jobId) {
+    return new JobRef(this, jobId);
+  }
+  async getJob(jobId) {
+    return new JobHandle(this, jobId, await this._getJobData(jobId));
+  }
+  async listJobs(options = {}) {
+    return this.transport.requestJson("GET", "/jobs", { query: options });
+  }
+  async *iterJobs(options = {}) {
+    let cursor;
+    while (true) {
+      const page = await this.listJobs({ ...options, cursor });
+      for (const job of page.jobs) {
+        yield new JobHandle(this, job.job_id, job);
+      }
+      cursor = page.next_cursor;
+      if (!cursor) return;
+    }
+  }
+  // ===== runs =====
+  /** A `RunRef` for an existing run with no network call. */
+  run(jobId, runId) {
+    return new RunRef(this, jobId, runId);
+  }
+  async getRun(jobId, runId) {
+    return new RunHandle(this, jobId, runId, await this._getRunData(jobId, runId));
+  }
+  async listRuns(jobId, options = {}) {
+    return this.transport.requestJson("GET", `/jobs/${jobId}/runs`, { query: options });
+  }
+  async *iterRuns(jobId, pageSize) {
+    let cursor;
+    while (true) {
+      const page = await this.listRuns(jobId, { limit: pageSize, cursor });
+      for (const run of page.runs) {
+        yield new RunHandle(this, jobId, run.run_id, run);
+      }
+      cursor = page.next_cursor;
+      if (!cursor) return;
+    }
+  }
+  // ===== results / content =====
+  async getResults(jobId, options = {}) {
+    const { runId, ...query } = options;
+    const path = runId ? `/jobs/${jobId}/runs/${runId}/results` : `/jobs/${jobId}/results`;
+    return this.transport.requestJson("GET", path, { query });
+  }
+  async *iterResults(jobId, options = {}) {
+    let cursor;
+    while (true) {
+      const page = await this.getResults(jobId, { ...options, cursor });
+      yield* page.results;
+      cursor = page.next_cursor;
+      if (!cursor) return;
+    }
+  }
+  /** Returns the scraped page's raw content as-is (HTML/text, not JSON). */
+  async getTaskContent(jobId, taskId, options = {}) {
+    const path = options.runId ? `/jobs/${jobId}/runs/${options.runId}/tasks/${taskId}/content` : `/jobs/${jobId}/tasks/${taskId}/content`;
+    const response = await this.transport.requestRaw("GET", path);
+    return response.text();
+  }
+  getTaskHistory(jobId, taskId, options = {}) {
+    const path = options.runId ? `/jobs/${jobId}/runs/${options.runId}/tasks/${taskId}/history` : `/jobs/${jobId}/tasks/${taskId}/history`;
+    return this.transport.requestJson("GET", path);
+  }
+  // ===== downloads =====
+  downloadToDir(jobId, runId, targetDir, opts = {}) {
+    return downloadToDir(
+      this.iterResults(jobId, { runId, status: opts.status ?? "successful" }),
+      targetDir,
+      opts
+    );
+  }
+  downloadToMemory(jobId, runId, opts = {}) {
+    return downloadToMemory(
+      this.iterResults(jobId, { runId, status: opts.status ?? "successful" }),
+      opts
+    );
+  }
+  downloadTaskToFile(task, target) {
+    return downloadTaskToFile(task, target);
+  }
+  downloadTaskToMemory(task) {
+    return downloadTaskToMemory(task);
+  }
+  // ===== webhooks =====
+  getJobWebhook(jobId) {
+    return this.transport.requestJson("GET", `/jobs/${jobId}/webhook`);
+  }
+  putJobWebhook(jobId, config) {
+    return this.transport.requestJson("PUT", `/jobs/${jobId}/webhook`, {
+      body: { signature: false, ...config }
+    });
+  }
+  async deleteJobWebhook(jobId) {
+    await this.transport.requestJson("DELETE", `/jobs/${jobId}/webhook`);
+  }
+  testWebhook(config) {
+    return this.transport.requestJson("POST", "/webhook/test", {
+      body: { signature: false, ...config }
+    });
+  }
+  // ===== HMAC key lifecycle =====
+  listHmacKeys() {
+    return this.transport.requestJson("GET", "/hmac/keys");
+  }
+  /** Capture the returned `secret` HERE — it is not revealed again. */
+  rotateHmacKey() {
+    return this.transport.requestJson("POST", "/hmac/keys/rotate");
+  }
+  finalizeHmacKey() {
+    return this.transport.requestJson("POST", "/hmac/keys/rotate/finalize");
+  }
+  async cancelHmacRotation() {
+    await this.transport.requestJson("DELETE", "/hmac/keys/rotate");
+  }
+  // ===== file inputs (CSV uploads) =====
+  createJobInput(body) {
+    return this.transport.requestJson("POST", "/job_inputs", { body });
+  }
+  /** Allocate a CSV slot + PUT the body. Returns the `file_input_id` to pass to `submitJob`. */
+  async uploadCsv(data, options) {
+    const created = await this.createJobInput({
+      type: "csv",
+      csv: {
+        delimiter: options.delimiter ?? ",",
+        quote: options.quote ?? '"',
+        header: options.header ?? false,
+        fields: options.fields
+      }
+    });
+    const headers = { "Content-Type": "text/csv", ...created.upload.headers ?? {} };
+    const response = await fetch(created.upload.url, {
+      method: created.upload.method,
+      headers,
+      body: data
+    });
+    if (!response.ok) {
+      throw new ZenRowsBatchError(response.status, void 0);
+    }
+    return created.file_input_id;
+  }
+  // ===== results exports =====
+  async startResultsExport(jobId, runId) {
+    const resp = await this._postExportStart(jobId, runId);
+    return new ExportRef(this, jobId, runId, resp.export_id, resp);
+  }
+  async getResultsExport(jobId, runId, exportId) {
+    return new ExportHandle(
+      this,
+      jobId,
+      runId,
+      exportId,
+      await this._getExport(jobId, runId, exportId)
+    );
+  }
+  async waitForExport(jobId, runId, exportId, options = {}) {
+    const target = options.targetStatuses ?? TERMINAL_EXPORT_STATUSES;
+    return pollUntil(() => this._getExport(jobId, runId, exportId), {
+      isDone: (e) => target.has(e.status),
+      timeout: options.timeout ?? 600,
+      initialInterval: options.pollInterval ?? 2,
+      maxInterval: options.maxPollInterval ?? 15
+    });
+  }
+  /** Start an export, wait for it, and save the zip to `targetPath`. Capped at 1 GiB per run. */
+  async downloadAllResults(jobId, runId, targetPath, options = {}) {
+    const exportRef = await this.startResultsExport(jobId, runId);
+    const final = await this.waitForExport(jobId, runId, exportRef.exportId, {
+      timeout: options.waitTimeout ?? 600,
+      pollInterval: options.pollInterval ?? 2
+    });
+    if (final.status !== "completed" || !final.download_url) {
+      throw new Error(final.error ?? "export completed but server returned no download_url");
+    }
+    const { mkdir: mkdir2 } = await import("fs/promises");
+    const { dirname: dirname2 } = await import("path");
+    const { createWriteStream: createWriteStream2 } = await import("fs");
+    const { Readable: Readable2 } = await import("stream");
+    const { pipeline: pipeline2 } = await import("stream/promises");
+    await mkdir2(dirname2(targetPath), { recursive: true });
+    const response = await fetch(final.download_url);
+    if (!response.ok) {
+      throw new ZenRowsBatchError(response.status, void 0);
+    }
+    await pipeline2(Readable2.fromWeb(response.body), createWriteStream2(targetPath));
+    return targetPath;
+  }
+  // ===== waiter =====
+  async waitForRun(jobId, options = {}) {
+    return this._waitForRunRaw(jobId, options);
+  }
+  // ==========================================================
+  // "raw" methods — no resource wrapping; used by handles internally.
+  // ==========================================================
+  /** @internal */
+  async _getJobData(jobId) {
+    return this.transport.requestJson("GET", `/jobs/${jobId}`);
+  }
+  /** @internal */
+  async _getRunData(jobId, runId) {
+    return this.transport.requestJson("GET", `/jobs/${jobId}/runs/${runId}`);
+  }
+  /** @internal */
+  async _postClose(jobId) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/close`);
+  }
+  /** @internal */
+  async _postStop(jobId) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/stop`);
+  }
+  /** @internal */
+  async _postPause(jobId) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/pause`);
+  }
+  /** @internal */
+  async _postResume(jobId) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/resume`);
+  }
+  /** @internal */
+  async _delete(jobId) {
+    await this.transport.requestJson("DELETE", `/jobs/${jobId}`);
+  }
+  /** @internal */
+  async _deleteRun(jobId, runId) {
+    await this.transport.requestJson("DELETE", `/jobs/${jobId}/runs/${runId}`);
+  }
+  /** @internal */
+  async _postRerun(jobId, options = {}) {
+    const status = Array.isArray(options.status) ? options.status.join(",") : options.status;
+    return this.transport.requestJson("POST", `/jobs/${jobId}/rerun`, {
+      query: status ? { status } : void 0,
+      idempotencyKey: options.idempotencyKey
+    });
+  }
+  /** @internal */
+  async _putSchedule(jobId, schedule) {
+    return this.transport.requestJson("PUT", `/jobs/${jobId}/schedule`, { body: schedule });
+  }
+  /** @internal */
+  async _postScheduleState(jobId, state) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/schedule/state`, {
+      body: { schedule_state: state }
+    });
+  }
+  /** @internal */
+  async _postTasks(jobId, tasks, options = {}) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/tasks`, {
+      body: { tasks, last_batch: options.lastBatch ?? false }
+    });
+  }
+  /** @internal */
+  async _postExportStart(jobId, runId) {
+    return this.transport.requestJson("POST", `/jobs/${jobId}/runs/${runId}/exports`);
+  }
+  /** @internal */
+  async _getExport(jobId, runId, exportId) {
+    return this.transport.requestJson("GET", `/jobs/${jobId}/runs/${runId}/exports/${exportId}`);
+  }
+  /** @internal */
+  async _waitForRunRaw(jobId, options) {
+    const target = options.targetStatuses ?? TERMINAL_RUN_STATUSES;
+    const fetchRun = async () => {
+      if (!options.runId) {
+        const job = await this._getJobData(jobId);
+        return job.latest_run;
+      }
+      return this._getRunData(jobId, options.runId);
+    };
+    return pollUntil(fetchRun, {
+      isDone: (run) => run !== void 0 && target.has(run.status),
+      isFailure: (run) => run !== void 0 && Boolean(options.failureStatuses?.has(run.status)),
+      timeout: options.timeout ?? 300,
+      initialInterval: options.pollInterval ?? 2,
+      maxInterval: options.maxPollInterval ?? 15
+      // biome-ignore lint/suspicious/noExplicitAny: fetchRun can resolve undefined for a not-yet-fired scheduled job
+    });
+  }
+  /** @internal */
+  async _waitForIngestRaw(jobId, options = {}) {
+    return pollUntil(() => this._getJobData(jobId), {
+      isDone: (job) => {
+        const run = job.latest_run;
+        if (!run || TERMINAL_RUN_STATUSES.has(run.status)) return true;
+        return run.ingest_status !== "pending";
+      },
+      timeout: options.timeout ?? 300,
+      initialInterval: options.pollInterval ?? 2,
+      maxInterval: options.maxPollInterval ?? 15
+    });
+  }
+};
+
+// src/batch/schedule.ts
+var DAYS_OF_WEEK = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+function validateTimezone(tz, field) {
+  if (!tz) {
+    throw new Error(`${field} is required (IANA name, e.g. "Europe/Berlin")`);
+  }
+  try {
+    new Intl.DateTimeFormat(void 0, { timeZone: tz });
+  } catch {
+    throw new Error(`${field}: ${JSON.stringify(tz)} is not a valid IANA timezone`);
+  }
+}
+function validateFullHour(s) {
+  if (s.length !== 5 || s[2] !== ":" || s.slice(3) !== "00") {
+    throw new Error(
+      `times_of_day entry ${JSON.stringify(s)} must be on the hour ("HH:00"); minute granularity is rejected.`
+    );
+  }
+  const h = Number(s.slice(0, 2));
+  if (!Number.isInteger(h) || h < 0 || h > 23) {
+    throw new Error(`times_of_day entry ${JSON.stringify(s)} is not a valid hour (00..23)`);
+  }
+}
+function hasTzSuffix(raw) {
+  const trimmed = raw.trim();
+  for (const sep of ["T", " "]) {
+    const i = trimmed.indexOf(sep);
+    if (i >= 0) {
+      const tail = trimmed.slice(i + 1);
+      if (tail.endsWith("Z") || tail.endsWith("z")) return true;
+      return tail.length >= 6 && (tail[tail.length - 6] === "+" || tail[tail.length - 6] === "-");
+    }
+  }
+  return false;
+}
+function formatLocalNaive(date) {
+  const pad = (n, width = 2) => String(n).padStart(width, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+var At = class {
+  at;
+  timezone;
+  constructor(at, timezone) {
+    validateTimezone(timezone, "At.timezone");
+    if (at instanceof Date) {
+      this.at = formatLocalNaive(at);
+    } else {
+      if (!at.trim()) {
+        throw new Error("At.at must be a non-empty ISO timestamp string.");
+      }
+      if (hasTzSuffix(at)) {
+        throw new Error(
+          `At.at ${JSON.stringify(at)} must be tz-naive (no "Z", no offset). Supply timezone separately to keep DST transitions deterministic.`
+        );
+      }
+      this.at = at;
+    }
+    this.timezone = timezone;
+  }
+  toRequestBody() {
+    return { at: this.at, timezone: this.timezone };
+  }
+};
+var Rate = class {
+  every;
+  unit;
+  constructor(every, unit) {
+    if (!Number.isInteger(every)) {
+      throw new TypeError(`Rate.every must be an integer, got ${every}`);
+    }
+    if (every < 1) {
+      throw new Error(`Rate.every must be >= 1, got ${every}`);
+    }
+    if (unit !== "minute" && unit !== "hour" && unit !== "day") {
+      throw new Error(
+        `Rate.unit must be one of "minute", "hour", "day"; got ${JSON.stringify(unit)}`
+      );
+    }
+    this.every = every;
+    this.unit = unit;
+  }
+  toRequestBody() {
+    return { rate: { every: this.every, unit: this.unit } };
+  }
+};
+var Daily = class {
+};
+var Weekly = class {
+  days;
+  constructor(days) {
+    if (!days.length) {
+      throw new Error("Weekly.days must be non-empty");
+    }
+    for (const d of days) {
+      if (!DAYS_OF_WEEK.includes(d)) {
+        throw new Error(
+          `Weekly.days entry ${JSON.stringify(d)} is not a valid day (use one of ${DAYS_OF_WEEK.join(", ")})`
+        );
+      }
+    }
+    this.days = days;
+  }
+};
+var Monthly = class {
+  days;
+  constructor(days) {
+    if (!days.length) {
+      throw new Error("Monthly.days must be non-empty");
+    }
+    for (const d of days) {
+      if (!Number.isInteger(d)) {
+        throw new TypeError(`Monthly.days entries must be integers, got ${d}`);
+      }
+      if (d < 1 || d > 31) {
+        throw new Error(`Monthly.days entry ${d} is out of range (1..31)`);
+      }
+    }
+    this.days = days;
+  }
+};
+var Calendar = class {
+  timesOfDay;
+  cadence;
+  timezone;
+  constructor(timesOfDay, cadence, timezone) {
+    validateTimezone(timezone, "Calendar.timezone");
+    if (!timesOfDay.length) {
+      throw new Error("Calendar.times_of_day must be non-empty");
+    }
+    for (const t of timesOfDay) {
+      validateFullHour(t);
+    }
+    this.timesOfDay = timesOfDay;
+    this.cadence = cadence;
+    this.timezone = timezone;
+  }
+  toRequestBody() {
+    let cadenceBody;
+    if (this.cadence instanceof Daily) {
+      cadenceBody = { daily: {} };
+    } else if (this.cadence instanceof Weekly) {
+      cadenceBody = { weekly: { days: [...this.cadence.days] } };
+    } else {
+      cadenceBody = { monthly: { days: [...this.cadence.days] } };
+    }
+    return {
+      calendar: { times_of_day: [...this.timesOfDay], cadence: cadenceBody },
+      timezone: this.timezone
+    };
+  }
+};
+
 // src/index.ts
 var API_URL = "https://api.zenrows.com/v1/";
+async function isAuth010(response) {
+  try {
+    const body = await response.clone().json();
+    return typeof body?.code === "string" && body.code.toUpperCase() === "AUTH010";
+  } catch {
+    return false;
+  }
+}
 var ZenRows = class {
   apiKey;
   clientConfig;
   queue;
   fetchWithRetry;
+  /** Client for the Batch API (async job/run/task model) — see `./batch.ts`. */
+  batch;
   constructor(apiKey, clientConfig = {}) {
     this.apiKey = apiKey;
     this.clientConfig = clientConfig;
+    this.batch = new ZenRowsBatchClient(apiKey);
     const retries = this.clientConfig.retries ?? 0;
     this.queue = fastq.promise(this, this.worker, this.clientConfig.concurrency ?? 5);
     this.fetchWithRetry = fetchRetry(fetch, {
@@ -78,9 +1346,47 @@ var ZenRows = class {
       }
     });
   }
-  get(url, config, { headers = {} } = {}) {
+  /**
+   * Fetch a URL through Zenrows — the main page-scraping product. This is the primary entry
+   * point; `get()` remains as a deprecated alias for existing callers.
+   */
+  fetch(url, config, { headers = {} } = {}) {
     return this.queue.push({ url, config, headers });
   }
+  /** @deprecated Use `fetch()` instead. Kept for backward compatibility. */
+  get(url, config, opts = {}) {
+    return this.fetch(url, config, opts);
+  }
+  /**
+   * Fetch a URL and run it through Extract — Zenrows' AI-powered structured extraction
+   * (beta). `mode` defaults to `"auto"`; pass `"native"` or `"standard"` to pick a
+   * different extraction contract. This is a thin, typed wrapper over `fetch()` with the
+   * `extract` param set — no separate endpoint or auth.
+   *
+   * Also sends Adaptive Stealth Mode (`mode: "auto"`) by default, so a target that needs
+   * `js_render`/`premium_proxy` gets escalated automatically instead of failing with
+   * REQS002 — pass `adaptiveStealth: false` to disable that and set `js_render`/
+   * `premium_proxy` yourself.
+   *
+   * `extract=auto` is a domain-gated open beta: when the target domain isn't enabled yet,
+   * the API returns a 402 with `code: "AUTH010"`. By default this method catches that and
+   * retries once with `autoparse: true` instead of returning the error response — pass
+   * `fallbackToAutoparse: false` to disable that and get the raw AUTH010 response back.
+   */
+  async extract(url, config, opts = {}) {
+    const {
+      extract = "auto",
+      fallbackToAutoparse = true,
+      adaptiveStealth = true,
+      ...rest
+    } = config ?? {};
+    const mode = adaptiveStealth ? "auto" : void 0;
+    const response = await this.fetch(url, { ...rest, extract, mode }, opts);
+    if (response.status === 402 && extract === "auto" && fallbackToAutoparse && await isAuth010(response)) {
+      return this.fetch(url, { ...rest, autoparse: true, mode }, opts);
+    }
+    return response;
+  }
   post(url, config, { headers = {}, data = {} } = {
     headers: { "Content-Type": "application/x-www-form-urlencoded" }
   }) {
@@ -150,5 +1456,39 @@ var ZenRows = class {
   }
 };
 export {
-  ZenRows
+  AUTO_MAX_CREDITS,
+  AUTO_MIN_CREDITS,
+  At,
+  BASE_CREDITS,
+  Calendar,
+  CurrentRun,
+  DEFAULT_MAX_BYTES_PER_FILE,
+  DEFAULT_MAX_COUNT_IN_MEMORY,
+  DEFAULT_MAX_FILES,
+  DEFAULT_MAX_TOTAL_BYTES_IN_MEMORY,
+  Daily,
+  ExportHandle,
+  ExportRef,
+  JS_AND_PROXY_CREDITS,
+  JS_CREDITS,
+  JobHandle,
+  JobRef,
+  Monthly,
+  PREMIUM_PROXY_CREDITS,
+  Rate,
+  RunHandle,
+  RunRef,
+  WaiterFailureError,
+  WaiterTimeoutError,
+  Weekly,
+  ZenRows,
+  ZenRowsBatchClient,
+  ZenRowsBatchError,
+  downloadTaskToFile,
+  downloadTaskToMemory,
+  downloadToDir,
+  downloadToMemory,
+  estimateCost,
+  parseProblem,
+  pollUntil
 };