@intuned/runtime-dev 1.3.15-hook.0 → 1.3.15-ts-helpers

package/dist/commands/intuned-cli/commands/run_authsession.command.d.ts

@@ -1,29 +1,29 @@
 import { Command } from "commander";
 export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodObject<{
     proxy: import("zod").ZodOptional<import("zod").ZodString>;
-    headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
     timeout: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodString>, import("ms").StringValue, string | undefined>, number, string | undefined>;
+    headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
     keepBrowserOpen: import("zod").ZodDefault<import("zod").ZodBoolean>;
     cdpUrl: import("zod").ZodOptional<import("zod").ZodString>;
-    trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
     checkAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
     createAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, "strip", import("zod").ZodTypeAny, {
-    headless: boolean;
+    trace: boolean;
     timeout: number;
+    headless: boolean;
     keepBrowserOpen: boolean;
-    trace: boolean;
     checkAttempts: number;
     createAttempts: number;
     proxy?: string | undefined;
     cdpUrl?: string | undefined;
 }, {
     proxy?: string | undefined;
-    headless?: boolean | undefined;
+    trace?: boolean | undefined;
     timeout?: string | undefined;
+    headless?: boolean | undefined;
     keepBrowserOpen?: boolean | undefined;
     cdpUrl?: string | undefined;
-    trace?: boolean | undefined;
     checkAttempts?: number | undefined;
     createAttempts?: number | undefined;
 }>;

package/dist/commands/intuned-cli/commands/types.d.ts

@@ -17,10 +17,10 @@ export declare const baseCommandOptionsSchema: z.ZodObject<{
     keepBrowserOpen: z.ZodDefault<z.ZodBoolean>;
     cdpUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    headless: boolean;
+    trace: boolean;
     timeout: number;
+    headless: boolean;
     keepBrowserOpen: boolean;
-    trace: boolean;
     proxy?: string | undefined;
     cdpUrl?: string | undefined;
 }, {

package/dist/commands/intuned-cli/controller/authSession.d.ts

@@ -18,8 +18,8 @@ export declare function executeRunCreateAuthSessionCLI({ id, input, checkRetries
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -49,8 +49,8 @@ export declare function executeRunUpdateAuthSessionCLI({ id, input, checkRetries
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -78,8 +78,8 @@ export declare function executeAttemptCreateAuthSessionCLI({ id, input, ...rest
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -106,8 +106,8 @@ export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -140,8 +140,8 @@ declare function runCreate({ authSessionInput, proxy, headless, timeout, traceId
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -177,8 +177,8 @@ declare function runCreateWithRetries({ authSessionId, authSessionInput, retries
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;

package/dist/commands/intuned-cli/helpers/auth.d.ts

@@ -8,8 +8,8 @@ export declare function loadAuthSessionInstance(authSessionId: string): Promise<
         cookies: {
             path: string;
             value: string;
-            name: string;
             domain: string;
+            name: string;
             expires: number;
             httpOnly: boolean;
             secure: boolean;

package/dist/common/{extensionsHelpers.d.ts → extension/extensionsHelpers.d.ts}

@@ -1,5 +1,5 @@
 import * as playwright from "playwright";
-import { CaptchaSolverSettingsWithRunContext } from "./settingsSchema";
+import { CaptchaSolverSettingsWithRunContext } from "../settingsSchema";
 export declare function buildExtensionsList(): string[];
 export declare function getIntunedExtensionPath(): string;
 export declare function isIntunedExtensionEnabled(): boolean;

package/dist/common/{extensionsHelpers.js → extension/extensionsHelpers.js}

@@ -9,15 +9,27 @@ exports.getIntunedExtensionSettings = getIntunedExtensionSettings;
 exports.getIntunedExtensionWorker = getIntunedExtensionWorker;
 exports.isIntunedExtensionEnabled = isIntunedExtensionEnabled;
 exports.setupIntunedExtension = setupIntunedExtension;
-var _settings = require("../commands/common/utils/settings");
-var _settingsSchema = require("./settingsSchema");
-var _constants = require("./constants");
-var _jwtTokenManager = require("./jwtTokenManager");
+var _settings = require("../../commands/common/utils/settings");
+var _settingsSchema = require("../settingsSchema");
+var _constants = require("../constants");
+var _jwtTokenManager = require("../jwtTokenManager");
 var _path = _interopRequireDefault(require("path"));
 var _promises = require("fs/promises");
+var _intunedExtensionServer = require("./intunedExtensionServer");
+var _portfinder = require("portfinder");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const INTUNED_WORKER = "intunedWorker.js";
 const INTUNED_EXTENSION_SETTINGS_FILE_NAME = "intunedSettings.json";
+const INTUNED_CAPTCHA_EXTENSION_PORT_ENV_VAR = "INTUNED_CAPTCHA_EXTENSION_PORT";
+function getIntunedCaptchaExtensionPortFromEnv() {
+  const raw = process.env[INTUNED_CAPTCHA_EXTENSION_PORT_ENV_VAR];
+  if (!raw) return null;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`Invalid ${INTUNED_CAPTCHA_EXTENSION_PORT_ENV_VAR}: ${raw}`);
+  }
+  return parsed;
+}
 function buildExtensionsList() {
   const extensionsList = [];
   if (isIntunedExtensionEnabled()) {
@@ -61,12 +73,35 @@ async function getIntunedExtensionSettings() {
     const missingEnvVars = [domain && "FUNCTIONS_DOMAIN", workspaceId && _constants.WORKSPACE_ID_ENV_VAR_KEY, projectId && `INTUNED_INTEGRATION_ID OR ${_constants.PROJECT_ID_ENV_VAR_KEY}`];
     throw new Error(`Missing required environment variables: ${missingEnvVars}`);
   }
+  const authentication = (() => {
+    if (process.env.INTUNED_API_KEY) {
+      return {
+        type: "apiKey",
+        apiKey: process.env.INTUNED_API_KEY
+      };
+    }
+    if (process.env.INTUNED_BASIC_AUTH_USERNAME && process.env.INTUNED_BASIC_AUTH_PASSWORD) {
+      const credentials = `${process.env.INTUNED_BASIC_AUTH_USERNAME}:${process.env.INTUNED_BASIC_AUTH_PASSWORD}`;
+      const token = Buffer.from(credentials, "utf-8").toString("base64");
+      return {
+        type: "basic",
+        token
+      };
+    }
+    return {
+      type: "bearer",
+      token: _jwtTokenManager.backendFunctionsTokenManager.token
+    };
+  })();
+  const baseUrl = process.env.INTUNED_API_BASE_URL ?? domain;
+  const port = getIntunedCaptchaExtensionPortFromEnv() ?? (await (0, _portfinder.getPort)({}));
   return {
     ...(settings.captchaSolver ?? _settingsSchema.captchaSolverSettingsSchema.parse({})),
     workspaceId,
     projectId,
-    baseUrl: domain,
-    token: _jwtTokenManager.backendFunctionsTokenManager.token
+    baseUrl,
+    authentication,
+    port
   };
 }
 async function setupIntunedExtension() {
@@ -76,5 +111,11 @@ async function setupIntunedExtension() {
   const intunedExtensionPath = getIntunedExtensionPath();
   const intunedExtensionSettingsPath = _path.default.join(intunedExtensionPath, INTUNED_EXTENSION_SETTINGS_FILE_NAME);
   const settings = await getIntunedExtensionSettings();
+  if (!settings.enabled) {
+    return;
+  }
+  await (0, _intunedExtensionServer.setupIntunedExtensionServer)({
+    port: settings.port ?? 9000
+  });
   await (0, _promises.writeFile)(intunedExtensionSettingsPath, JSON.stringify(settings));
 }

package/dist/common/extension/intunedExtensionServer.d.ts

@@ -0,0 +1,27 @@
+import type * as playwright from "playwright";
+import { Captcha, CaptchaCallback, CaptchaStatus } from "./types";
+export declare class ExtensionServer {
+    private tabs;
+    private app;
+    isHealthy: boolean;
+    constructor();
+    private getOrCreateTab;
+    handleUpsertCaptcha(captcha: Captcha): Promise<void>;
+    start({ port, host, }: {
+        port: number;
+        host?: string;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    getCaptchas(page: playwright.Page, status?: CaptchaStatus): Promise<Captcha[]>;
+    subscribe(page: playwright.Page, handler: CaptchaCallback, status?: CaptchaStatus): Promise<void>;
+    unsubscribe(page: playwright.Page, handler: CaptchaCallback, status?: CaptchaStatus): Promise<void>;
+    removeTab(tabId: number): void;
+    getTabId(page: playwright.Page): Promise<number>;
+}
+export declare function getIntunedExtensionServer(): ExtensionServer;
+export declare function setupIntunedExtensionServer({ port, host, }: {
+    port: number;
+    host?: string;
+}): Promise<void>;
+export declare function cleanIntunedExtensionServer(): Promise<void>;
+export declare function getTabId(page: playwright.Page): Promise<number>;

package/dist/common/extension/intunedExtensionServer.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExtensionServer = void 0;
+exports.cleanIntunedExtensionServer = cleanIntunedExtensionServer;
+exports.getIntunedExtensionServer = getIntunedExtensionServer;
+exports.getTabId = getTabId;
+exports.setupIntunedExtensionServer = setupIntunedExtensionServer;
+var _fastify = _interopRequireDefault(require("fastify"));
+var _types = require("./types");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class TabCaptchaState {
+  constructor(tabId) {
+    this.tabId = tabId;
+    this.captchasById = new Map();
+    this.subscribers = new Array();
+  }
+  subscribe(handler) {
+    this.subscribers.push(handler);
+  }
+  unsubscribe(handler, status) {
+    const index = this.subscribers.findIndex(subscriber => subscriber.handler === handler && (subscriber.status === status || !status));
+    if (index !== -1) {
+      this.subscribers.splice(index, 1);
+    }
+  }
+  getCaptchas() {
+    return [...this.captchasById.values()];
+  }
+  async upsertCaptcha(captcha) {
+    this.captchasById.set(captcha.id, captcha);
+    for (const subscriber of this.subscribers) {
+      if (!subscriber.status || subscriber.status === captcha.status) {
+        await subscriber.handler(captcha);
+      }
+    }
+  }
+}
+class ExtensionServer {
+  app = null;
+  isHealthy = false;
+  constructor() {
+    this.tabs = new Map();
+  }
+  getOrCreateTab(tabId) {
+    const existing = this.tabs.get(tabId);
+    if (existing) return existing;
+    const created = new TabCaptchaState(tabId);
+    this.tabs.set(tabId, created);
+    return created;
+  }
+  async handleUpsertCaptcha(captcha) {
+    const tab = this.getOrCreateTab(captcha.tabId);
+    await tab.upsertCaptcha(captcha);
+  }
+  async start({
+    port,
+    host = "0.0.0.0"
+  }) {
+    if (this.app) {
+      return;
+    }
+    this.app = (0, _fastify.default)({
+      logger: false,
+      bodyLimit: 1_000_000
+    });
+    this.app.post("/state", async (request, reply) => {
+      try {
+        const result = _types.captchaSchema.safeParse(request.body);
+        if (!result.success) {
+          return reply.code(400).send({
+            error: "Invalid captcha payload",
+            details: result.error.flatten().fieldErrors
+          });
+        }
+        await this.handleUpsertCaptcha(result.data);
+        return reply.code(200).send({});
+      } catch (error) {
+        console.error("Error processing captcha state update:", error);
+        return reply.code(500).send({
+          error: "Internal server error",
+          message: error?.message ?? String(error)
+        });
+      }
+    });
+    this.app.setNotFoundHandler((_request, reply) => {
+      return reply.code(404).send({
+        error: "Not found"
+      });
+    });
+    await this.app.listen({
+      port,
+      host
+    });
+    this.isHealthy = true;
+  }
+  async stop() {
+    if (!this.app) return;
+    const toClose = this.app;
+    this.app = null;
+    this.isHealthy = false;
+    await toClose.close();
+  }
+  async getCaptchas(page, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return [];
+    const captchas = tab.getCaptchas();
+    if (!status) return captchas;
+    return captchas.filter(c => c.status === status && c.tabId === tabId);
+  }
+  async subscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.getOrCreateTab(tabId);
+    tab.subscribe({
+      handler,
+      status
+    });
+  }
+  async unsubscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    tab.unsubscribe(handler, status);
+  }
+  removeTab(tabId) {
+    this.tabs.delete(tabId);
+  }
+  async getTabId(page) {
+    return await getTabId(page);
+  }
+}
+exports.ExtensionServer = ExtensionServer;
+let extensionServerSingleton = null;
+function getIntunedExtensionServer() {
+  if (!extensionServerSingleton) {
+    throw new Error("Intuned Extension Server is not initialized.");
+  }
+  return extensionServerSingleton;
+}
+async function setupIntunedExtensionServer({
+  port,
+  host
+}) {
+  if (!extensionServerSingleton) {
+    extensionServerSingleton = new ExtensionServer();
+  }
+  await extensionServerSingleton.start({
+    port,
+    host
+  });
+}
+async function cleanIntunedExtensionServer() {
+  if (extensionServerSingleton) {
+    await extensionServerSingleton.stop();
+    extensionServerSingleton = null;
+  }
+}
+const TAB_ID_CACHE_KEY = "__INTUNED_CACHED_TAB_ID__";
+async function getTabId(page) {
+  const cached = page[TAB_ID_CACHE_KEY];
+  if (cached !== undefined && typeof cached === "number") {
+    return cached;
+  }
+  let tabId;
+  try {
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__", {
+      timeout: 100
+    });
+  } catch {
+    await page.waitForFunction("window.__INTUNED_TAB_ID__ !== undefined", {
+      timeout: 15_000
+    });
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__");
+  }
+  const numericTabId = Number(tabId);
+  page[TAB_ID_CACHE_KEY] = numericTabId;
+  return numericTabId;
+}

package/dist/common/extension/types.d.ts

@@ -0,0 +1,212 @@
+import { z } from "zod";
+export declare const captchaTypeSchema: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+export type CaptchaType = z.infer<typeof captchaTypeSchema>;
+export declare const captchaStatusSchema: z.ZodEnum<["attached", "solving", "solved", "error", "detached"]>;
+export type CaptchaStatus = z.infer<typeof captchaStatusSchema>;
+export declare const captchaErrorCodeSchema: z.ZodEnum<["HIT_LIMIT", "MAX_RETRIES", "UNEXPECTED_SERVER_RESPONSE", "UNEXPECTED_ERROR"]>;
+export type CaptchaErrorCode = z.infer<typeof captchaErrorCodeSchema>;
+export declare const captchaErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<["HIT_LIMIT", "MAX_RETRIES", "UNEXPECTED_SERVER_RESPONSE", "UNEXPECTED_ERROR"]>;
+    error: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+    error?: unknown;
+}, {
+    code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+    error?: unknown;
+}>;
+export type CaptchaError = z.infer<typeof captchaErrorSchema>;
+declare const captchaBaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>;
+export type CaptchaBase = z.infer<typeof captchaBaseSchema>;
+declare const captchaNonErrorSchema: z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<["attached", "solving", "solved", "detached"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "attached" | "solving" | "solved" | "detached";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "attached" | "solving" | "solved" | "detached";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>;
+export type CaptchaNonError = z.infer<typeof captchaNonErrorSchema>;
+declare const captchaErrorStatusSchema: z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["HIT_LIMIT", "MAX_RETRIES", "UNEXPECTED_SERVER_RESPONSE", "UNEXPECTED_ERROR"]>;
+        error: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    }, {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    };
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "error";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    error: {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    };
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "error";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>;
+export type CaptchaErrorStatus = z.infer<typeof captchaErrorStatusSchema>;
+export declare const captchaSchema: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodLiteral<"attached">;
+}, "strip", z.ZodTypeAny, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "attached";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "attached";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodLiteral<"solving">;
+}, "strip", z.ZodTypeAny, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "solving";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "solving";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodLiteral<"solved">;
+}, "strip", z.ZodTypeAny, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "solved";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "solved";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodLiteral<"detached">;
+}, "strip", z.ZodTypeAny, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "detached";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "detached";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodEnum<["aws", "cloudflare", "customcaptcha", "funcaptcha", "geetest", "hcaptcha", "lemincaptcha", "recaptcha", "textcaptcha"]>;
+    id: z.ZodString;
+    tabId: z.ZodNumber;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["HIT_LIMIT", "MAX_RETRIES", "UNEXPECTED_SERVER_RESPONSE", "UNEXPECTED_ERROR"]>;
+        error: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    }, {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    };
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "error";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}, {
+    error: {
+        code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+        error?: unknown;
+    };
+    type: "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+    status: "error";
+    id: string;
+    tabId: number;
+    retryCount?: number | undefined;
+}>]>;
+export type Captcha = z.infer<typeof captchaSchema>;
+export type CaptchaCallback = (captcha: Captcha) => Promise<void> | void;
+export declare class CaptchaSolveError extends Error {
+    error: CaptchaError;
+    constructor(message: string, error: CaptchaError);
+}
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+export {};