@maaxyz/maa-node 0.0.1-alpha.2

package/dist/index.js

@@ -0,0 +1,1028 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/maa.js
+var require_maa = __commonJS({
+  "src/maa.js"(exports2, module2) {
+    "use strict";
+    if (!globalThis.MaaAPI) {
+      switch (`${process.platform}-${process.arch}`) {
+        case "win32-x64":
+          globalThis.MaaAPI = require("@maaxyz/maa-node-win32-x64");
+          break;
+        case "win32-arm64":
+          globalThis.MaaAPI = require("@maaxyz/maa-node-win32-arm64");
+          break;
+        case "linux-x64":
+          globalThis.MaaAPI = require("@maaxyz/maa-node-linux-x64");
+          break;
+        case "linux-arm64":
+          globalThis.MaaAPI = require("@maaxyz/maa-node-linux-arm64");
+          break;
+        case "darwin-x64":
+          globalThis.MaaAPI = require("@maaxyz/maa-node-darwin-x64");
+          break;
+        case "darwin-arm64":
+          globalThis.MaaAPI = require("@maaxyz/maa-node-darwin-arm64");
+          break;
+        default:
+          globalThis.MaaAPI = {};
+          break;
+      }
+    }
+    module2.exports = globalThis.MaaAPI;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AdbController: () => AdbController,
+  Context: () => Context,
+  ControllerBase: () => ControllerBase,
+  CustomController: () => CustomController,
+  CustomControllerActor: () => CustomControllerActor,
+  CustomControllerActorDefaultImpl: () => CustomControllerActorDefaultImpl,
+  DbgController: () => DbgController,
+  Global: () => Global,
+  Pi: () => Pi,
+  Resource: () => Resource,
+  ResourceBase: () => ResourceBase,
+  Tasker: () => Tasker,
+  TaskerBase: () => TaskerBase,
+  Win32Controller: () => Win32Controller,
+  api: () => api,
+  pp: () => pp
+});
+module.exports = __toCommonJS(src_exports);
+var api = __toESM(require_maa());
+
+// src/controller.ts
+var import_path = __toESM(require("path"));
+
+// src/job.ts
+var maa = __toESM(require_maa());
+var Job = class {
+  source;
+  id;
+  #status;
+  constructor(source, id) {
+    this.source = source;
+    this.id = id;
+    this.#status = null;
+  }
+  get status() {
+    return this.#status ?? this.source.status(this.id);
+  }
+  wait() {
+    const realWait = async () => {
+      this.#status = await this.source.wait(this.id);
+      return this;
+    };
+    const pro = realWait();
+    for (const key of ["status", "done", "succeeded", "failed"]) {
+      Object.defineProperty(pro, key, {
+        get: () => {
+          return new Promise((resolve) => {
+            pro.then((self) => {
+              resolve(self[key]);
+            });
+          });
+        }
+      });
+    }
+    return pro;
+  }
+  get done() {
+    return [maa.Status.Succeeded, maa.Status.Failed].includes(this.status);
+  }
+  get succeeded() {
+    return this.status == maa.Status.Succeeded;
+  }
+  get failed() {
+    return this.status == maa.Status.Failed;
+  }
+  get running() {
+    return this.status == maa.Status.Running;
+  }
+  get pending() {
+    return this.status == maa.Status.Pending;
+  }
+};
+
+// src/controller.ts
+var import_maa = __toESM(require_maa());
+var ImageJob = class extends Job {
+  #ctrl;
+  constructor(ctrl, source, id) {
+    super(source, id);
+    this.#ctrl = ctrl;
+  }
+  get() {
+    if (this.done) {
+      return this.#ctrl.cached_image;
+    } else {
+      return null;
+    }
+  }
+  wait() {
+    const superPro = super.wait();
+    const pro = superPro;
+    pro.get = () => {
+      return new Promise((resolve) => {
+        pro.then((self) => {
+          resolve(self.get());
+        });
+      });
+    };
+    return pro;
+  }
+};
+var ControllerBase = class {
+  handle;
+  #source;
+  notify(message, details_json) {
+  }
+  set parsed_notify(cb) {
+    this.notify = (msg, details) => {
+      return cb({
+        msg: msg.replace(/^Controller\./, ""),
+        ...JSON.parse(details)
+      });
+    };
+  }
+  constructor(handle) {
+    this.handle = handle;
+    this.#source = {
+      status: (id) => import_maa.default.controller_status(this.handle, id),
+      wait: (id) => import_maa.default.controller_wait(this.handle, id)
+    };
+  }
+  destroy() {
+    import_maa.default.controller_destroy(this.handle);
+  }
+  set screenshot_target_long_side(value) {
+    if (!import_maa.default.controller_set_option_screenshot_target_long_side(this.handle, value)) {
+      throw "Controller set screenshot_target_long_side failed";
+    }
+  }
+  set screenshot_target_short_side(value) {
+    if (!import_maa.default.controller_set_option_screenshot_target_short_side(this.handle, value)) {
+      throw "Controller set screenshot_target_short_side failed";
+    }
+  }
+  set screenshot_use_raw_size(value) {
+    if (!import_maa.default.controller_set_option_screenshot_use_raw_size(this.handle, value)) {
+      throw "Controller set screenshot_use_raw_size failed";
+    }
+  }
+  set recording(value) {
+    if (!import_maa.default.controller_set_option_recording(this.handle, value)) {
+      throw "Controller set recording failed";
+    }
+  }
+  post_connection() {
+    return new Job(this.#source, import_maa.default.controller_post_connection(this.handle));
+  }
+  post_click(x, y) {
+    return new Job(this.#source, import_maa.default.controller_post_click(this.handle, x, y));
+  }
+  post_swipe(x1, y1, x2, y2, duration) {
+    return new Job(
+      this.#source,
+      import_maa.default.controller_post_swipe(this.handle, x1, y1, x2, y2, duration)
+    );
+  }
+  post_press_key(keycode) {
+    return new Job(this.#source, import_maa.default.controller_post_press_key(this.handle, keycode));
+  }
+  post_input_text(text) {
+    return new Job(this.#source, import_maa.default.controller_post_input_text(this.handle, text));
+  }
+  post_start_app(intent) {
+    return new Job(this.#source, import_maa.default.controller_post_start_app(this.handle, intent));
+  }
+  post_stop_app(intent) {
+    return new Job(this.#source, import_maa.default.controller_post_stop_app(this.handle, intent));
+  }
+  post_touch_down(contact, x, y, pressure) {
+    return new Job(
+      this.#source,
+      import_maa.default.controller_post_touch_down(this.handle, contact, x, y, pressure)
+    );
+  }
+  post_touch_move(contact, x, y, pressure) {
+    return new Job(
+      this.#source,
+      import_maa.default.controller_post_touch_move(this.handle, contact, x, y, pressure)
+    );
+  }
+  post_touch_up(contact) {
+    return new Job(this.#source, import_maa.default.controller_post_touch_up(this.handle, contact));
+  }
+  post_screencap() {
+    return new ImageJob(this, this.#source, import_maa.default.controller_post_screencap(this.handle));
+  }
+  get connected() {
+    return import_maa.default.controller_connected(this.handle);
+  }
+  get cached_image() {
+    return import_maa.default.controller_cached_image(this.handle);
+  }
+  get uuid() {
+    return import_maa.default.controller_get_uuid(this.handle);
+  }
+};
+var AdbController = class _AdbController extends ControllerBase {
+  constructor(adb_path, address, screencap_methods, input_methods, config, agent) {
+    let ws;
+    const h = import_maa.default.adb_controller_create(
+      adb_path,
+      address,
+      screencap_methods,
+      input_methods,
+      config,
+      agent ?? _AdbController.agent_path(),
+      (message, details_json) => {
+        ws.deref()?.notify(message, details_json);
+      }
+    );
+    if (!h) {
+      throw "AdbController create failed";
+    }
+    super(h);
+    ws = new WeakRef(this);
+  }
+  static agent_path() {
+    return import_path.default.join(__dirname, "..", "agent");
+  }
+  static async find(adb) {
+    return import_maa.default.find_adb(adb ?? null);
+  }
+};
+var Win32Controller = class extends ControllerBase {
+  constructor(hwnd, screencap_methods, input_methods) {
+    let ws;
+    const h = import_maa.default.win32_controller_create(
+      hwnd ?? "0",
+      screencap_methods,
+      input_methods,
+      (message, details_json) => {
+        ws.deref()?.notify(message, details_json);
+      }
+    );
+    if (!h) {
+      throw "Win32Controller create failed";
+    }
+    super(h);
+    ws = new WeakRef(this);
+  }
+  static find() {
+    return import_maa.default.find_desktop();
+  }
+};
+var DbgController = class extends ControllerBase {
+  constructor(read_path, write_path, type, config) {
+    let ws;
+    const h = import_maa.default.dbg_controller_create(
+      read_path,
+      write_path,
+      type,
+      config,
+      (message, details_json) => {
+        ws.deref()?.notify(message, details_json);
+      }
+    );
+    if (!h) {
+      throw "DbgController create failed";
+    }
+    super(h);
+    ws = new WeakRef(this);
+  }
+};
+var CustomControllerActor = class {
+};
+var CustomControllerActorDefaultImpl = class extends CustomControllerActor {
+  connect() {
+    return false;
+  }
+  request_uuid() {
+    return null;
+  }
+  start_app(intent) {
+    return false;
+  }
+  stop_app(intent) {
+    return false;
+  }
+  screencap() {
+    return null;
+  }
+  click(x, y) {
+    return false;
+  }
+  swipe(x1, y1, x2, y2, duration) {
+    return false;
+  }
+  touch_down(contact, x, y, pressure) {
+    return false;
+  }
+  touch_move(contact, x, y, pressure) {
+    return false;
+  }
+  touch_up(contact) {
+    return false;
+  }
+  press_key(keycode) {
+    return false;
+  }
+  input_text(text) {
+    return false;
+  }
+};
+var CustomController = class extends ControllerBase {
+  constructor(actor) {
+    let ws;
+    const h = import_maa.default.custom_controller_create(
+      (action, ...param) => {
+        return actor[action](...param);
+      },
+      (message, details_json) => {
+        ws.deref()?.notify(message, details_json);
+      }
+    );
+    if (!h) {
+      throw "CustomController create failed";
+    }
+    super(h);
+    ws = new WeakRef(this);
+  }
+};
+
+// src/context.ts
+var maa4 = __toESM(require_maa());
+
+// src/tasker.ts
+var import_maa2 = __toESM(require_maa());
+var TaskJob = class extends Job {
+  #tasker;
+  constructor(tasker, source, id) {
+    super(source, id);
+    this.#tasker = tasker;
+  }
+  get() {
+    if (this.done) {
+      return this.#tasker.task_detail(this.id);
+    } else {
+      return null;
+    }
+  }
+  wait() {
+    const superPro = super.wait();
+    const pro = superPro;
+    pro.get = () => {
+      return new Promise((resolve) => {
+        pro.then((self) => {
+          resolve(self.get());
+        });
+      });
+    };
+    return pro;
+  }
+};
+var TaskerBase = class {
+  handle;
+  #source;
+  notify(message, details_json) {
+  }
+  set parsed_notify(cb) {
+    this.notify = (msg, details) => {
+      return cb({
+        msg: msg.replace(/^Task(?:er)?\./, ""),
+        ...JSON.parse(details)
+      });
+    };
+  }
+  constructor(handle) {
+    this.handle = handle;
+    this.#source = {
+      status: (id) => import_maa2.default.tasker_status(this.handle, id),
+      wait: (id) => import_maa2.default.tasker_wait(this.handle, id)
+    };
+  }
+  destroy() {
+    import_maa2.default.tasker_destroy(this.handle);
+  }
+  bind(slave) {
+    let ret;
+    if (slave instanceof ControllerBase) {
+      ret = import_maa2.default.tasker_bind_controller(this.handle, slave.handle);
+    } else {
+      ret = import_maa2.default.tasker_bind_resource(this.handle, slave.handle);
+    }
+    if (!ret) {
+      throw "Tasker bind failed";
+    }
+  }
+  post_pipeline(entry, param = {}) {
+    return new TaskJob(
+      this,
+      this.#source,
+      import_maa2.default.tasker_post_pipeline(this.handle, entry, JSON.stringify(param))
+    );
+  }
+  get inited() {
+    return import_maa2.default.tasker_inited(this.handle);
+  }
+  get running() {
+    return import_maa2.default.tasker_running(this.handle);
+  }
+  post_stop() {
+    return new TaskJob(
+      this,
+      this.#source,
+      import_maa2.default.tasker_post_stop(this.handle)
+    );
+  }
+  get resource() {
+    const res = import_maa2.default.tasker_get_resource(this.handle);
+    if (res) {
+      return new ResourceBase(res);
+    } else {
+      return null;
+    }
+  }
+  get controller() {
+    const ctrl = import_maa2.default.tasker_get_controller(this.handle);
+    if (ctrl) {
+      return new ControllerBase(ctrl);
+    } else {
+      return null;
+    }
+  }
+  clear_cache() {
+    if (!import_maa2.default.tasker_clear_cache(this.handle)) {
+      throw "Tasker clear_cache failed";
+    }
+  }
+  recognition_detail(id) {
+    const dt = import_maa2.default.tasker_get_recognition_detail(this.handle, id);
+    if (dt) {
+      const [name, algorithm, hit, box, detail, raw, draws] = dt;
+      return {
+        name,
+        algorithm,
+        hit,
+        box,
+        detail,
+        raw,
+        draws
+      };
+    } else {
+      return null;
+    }
+  }
+  node_detail(id) {
+    const dt = import_maa2.default.tasker_get_node_detail(this.handle, id);
+    if (dt) {
+      const [name, reco_id, completed] = dt;
+      return {
+        name,
+        reco: this.recognition_detail(reco_id),
+        completed
+      };
+    } else {
+      return null;
+    }
+  }
+  task_detail(id) {
+    const dt = import_maa2.default.tasker_get_task_detail(this.handle, id);
+    if (dt) {
+      const [entry, node_ids, status] = dt;
+      return {
+        entry,
+        nodes: node_ids.map((i) => this.node_detail(i)),
+        status
+      };
+    } else {
+      return null;
+    }
+  }
+  latest_node(task) {
+    return import_maa2.default.tasker_get_latest_node(this.handle, task);
+  }
+};
+var Tasker = class extends TaskerBase {
+  constructor() {
+    let ws;
+    const h = import_maa2.default.tasker_create((message, details_json) => {
+      ws.deref()?.notify(message, details_json);
+    });
+    if (!h) {
+      throw "Tasker create failed";
+    }
+    super(h);
+    ws = new WeakRef(this);
+  }
+};
+
+// src/context.ts
+var Context = class _Context {
+  handle;
+  #tasker;
+  constructor(handle) {
+    this.handle = handle;
+    this.#tasker = new TaskerBase(maa4.context_get_tasker(this.handle));
+  }
+  async run_pipeline(entry, pipeline_override = {}) {
+    const id = await maa4.context_run_pipeline(
+      this.handle,
+      entry,
+      JSON.stringify(pipeline_override)
+    );
+    return this.#tasker.task_detail(id);
+  }
+  async run_recognition(entry, image, pipeline_override = {}) {
+    if (image instanceof Buffer) {
+      image = image.buffer;
+    }
+    const id = await maa4.context_run_recognition(
+      this.handle,
+      entry,
+      JSON.stringify(pipeline_override),
+      image
+    );
+    return this.#tasker.recognition_detail(id);
+  }
+  async run_action(entry, box, reco_detail, pipeline_override = {}) {
+    const id = await maa4.context_run_action(
+      this.handle,
+      entry,
+      JSON.stringify(pipeline_override),
+      box,
+      reco_detail
+    );
+    return this.#tasker.node_detail(id);
+  }
+  override_pipeline(pipeline_override) {
+    if (!maa4.context_override_pipeline(this.handle, JSON.stringify(pipeline_override))) {
+      throw "Context override_pipeline failed";
+    }
+  }
+  override_next(name, next) {
+    if (!maa4.context_override_next(this.handle, name, next)) {
+      throw "Context override_next failed";
+    }
+  }
+  get task_id() {
+    return maa4.context_get_task_id(this.handle);
+  }
+  get tasker() {
+    return this.#tasker;
+  }
+  clone() {
+    return new _Context(maa4.context_clone(this.handle));
+  }
+};
+
+// src/resource.ts
+var import_maa3 = __toESM(require_maa());
+var ResourceBase = class {
+  handle;
+  #source;
+  notify(message, details_json) {
+  }
+  set parsed_notify(cb) {
+    this.notify = (msg, details) => {
+      return cb({
+        msg: msg.replace(/^Resource\./, ""),
+        ...JSON.parse(details)
+      });
+    };
+  }
+  constructor(handle) {
+    this.handle = handle;
+    this.#source = {
+      status: (id) => import_maa3.default.resource_status(this.handle, id),
+      wait: (id) => import_maa3.default.resource_wait(this.handle, id)
+    };
+  }
+  destroy() {
+    import_maa3.default.resource_destroy(this.handle);
+  }
+  set inference_device(id) {
+    if (typeof id === "string") {
+      id = import_maa3.default.InferenceDevice[id];
+    }
+    if (!import_maa3.default.resource_set_option_inference_device(this.handle, id)) {
+      throw "Resource set inference_device failed";
+    }
+  }
+  set inference_execution_provider(provider) {
+    if (!import_maa3.default.resource_set_option_inference_execution_provider(
+      this.handle,
+      import_maa3.default.InferenceExecutionProvider[provider]
+    )) {
+      throw "Resource set inference_execution_provider failed";
+    }
+  }
+  register_custom_recognizer(name, func) {
+    if (!import_maa3.default.resource_register_custom_recognition(
+      this.handle,
+      name,
+      (context, id, task, name2, param, image, roi) => {
+        const self = {
+          context: new Context(context),
+          id,
+          task,
+          name: name2,
+          param: JSON.parse(param),
+          image,
+          roi
+        };
+        return func.apply(self, [self]);
+      }
+    )) {
+      throw "Resource register_custom_recognition failed";
+    }
+  }
+  unregister_custom_recognizer(name) {
+    if (!import_maa3.default.resource_unregister_custom_recognition(this.handle, name)) {
+      throw "Resource unregister_custom_recognition failed";
+    }
+  }
+  clear_custom_recognizer() {
+    if (!import_maa3.default.resource_clear_custom_recognition(this.handle)) {
+      throw "Resource clear_custom_recognition failed";
+    }
+  }
+  register_custom_action(name, func) {
+    if (!import_maa3.default.resource_register_custom_action(
+      this.handle,
+      name,
+      (context, id, task, name2, param, recoId, box) => {
+        const self = {
+          context: new Context(context),
+          id,
+          task,
+          name: name2,
+          param: JSON.parse(param),
+          recoId,
+          box
+        };
+        return func.apply(self, [self]);
+      }
+    )) {
+      throw "Resource register_custom_action failed";
+    }
+  }
+  unregister_custom_action(name) {
+    if (!import_maa3.default.resource_unregister_custom_action(this.handle, name)) {
+      throw "Resource unregister_custom_action failed";
+    }
+  }
+  clear_custom_action() {
+    if (!import_maa3.default.resource_clear_custom_action(this.handle)) {
+      throw "Resource clear_custom_action failed";
+    }
+  }
+  post_path(path2) {
+    return new Job(this.#source, import_maa3.default.resource_post_path(this.handle, path2));
+  }
+  clear() {
+    if (!import_maa3.default.resource_clear(this.handle)) {
+      throw "Resource clear failed";
+    }
+  }
+  get loaded() {
+    return import_maa3.default.resource_loaded(this.handle);
+  }
+  get hash() {
+    return import_maa3.default.resource_get_hash(this.handle);
+  }
+  get task_list() {
+    return import_maa3.default.resource_get_task_list(this.handle);
+  }
+};
+var Resource = class extends ResourceBase {
+  constructor() {
+    let ws;
+    const h = import_maa3.default.resource_create((message, details_json) => {
+      ws.deref()?.notify(message, details_json);
+    });
+    if (!h) {
+      throw "Resource create failed";
+    }
+    super(h);
+    ws = new WeakRef(this);
+  }
+};
+
+// src/global.ts
+var maa6 = __toESM(require_maa());
+var Global = {
+  get version() {
+    return maa6.version();
+  },
+  set log_dir(value) {
+    if (!maa6.set_global_option_log_dir(value)) {
+      throw "Global set log_dir failed";
+    }
+  },
+  set save_draw(value) {
+    if (!maa6.set_global_option_save_draw(value)) {
+      throw "Global set save_draw failed";
+    }
+  },
+  set recording(value) {
+    if (!maa6.set_global_option_recording(value)) {
+      throw "Global set recording failed";
+    }
+  },
+  set stdout_level(value) {
+    if (!maa6.set_global_option_stdout_level(maa6.LoggingLevel[value])) {
+      throw "Global set stdout_level failed";
+    }
+  },
+  set show_hit_draw(value) {
+    if (!maa6.set_global_option_show_hit_draw(value)) {
+      throw "Global set show_hit_draw failed";
+    }
+  },
+  set debug_mode(value) {
+    if (!maa6.set_global_option_debug_mode(value)) {
+      throw "Global set debug_mode failed";
+    }
+  },
+  config_init_option(user_path, default_json = "{}") {
+    if (!maa6.config_init_option(user_path, default_json)) {
+      throw "Global config_init_option failed";
+    }
+  }
+};
+
+// src/pi.ts
+var maa7 = __toESM(require_maa());
+var Pi = {
+  __running: false,
+  notify(message, details_json) {
+  },
+  register_custom_recognizer(id, name, func) {
+    maa7.pi_register_custom_recognizer(id, name, (context, id2, task, name2, param, image, roi) => {
+      const self = {
+        context: new Context(context),
+        id: id2,
+        task,
+        name: name2,
+        param: JSON.parse(param),
+        image,
+        roi
+      };
+      return func.apply(self, [self]);
+    });
+  },
+  register_custom_action(id, name, func) {
+    maa7.pi_register_custom_action(id, name, (context, id2, task, name2, param, recoId, box) => {
+      const self = {
+        context: new Context(context),
+        id: id2,
+        task,
+        name: name2,
+        param: JSON.parse(param),
+        recoId,
+        box
+      };
+      return func.apply(self, [self]);
+    });
+  },
+  async run_cli(id, resource_path, user_path, directly) {
+    if (Pi.__running) {
+      return false;
+    }
+    Pi.__running = true;
+    const res = await maa7.pi_run_cli(
+      id,
+      resource_path,
+      user_path,
+      directly,
+      (message, details) => {
+        return Pi.notify(message, details);
+      }
+    );
+    Pi.__running = false;
+    return res;
+  }
+};
+
+// src/pipeline.ts
+function pp() {
+  const self = new Proxy(
+    {
+      __json: {}
+    },
+    {
+      get(target, key) {
+        switch (key) {
+          case "done":
+            return target.__json;
+          case "recognition":
+            return (val) => {
+              target.__json[key] = val;
+              const sub_self = new Proxy(
+                { __json: {} },
+                {
+                  get(sub_target, sub_key) {
+                    switch (sub_key) {
+                      case "done":
+                        Object.assign(target.__json, sub_target.__json);
+                        return self;
+                      case "threshold$":
+                      case "order_by":
+                      case "index":
+                      case "method":
+                      case "green_mask":
+                      case "count":
+                      case "detector":
+                      case "ratio":
+                      case "connected":
+                      case "only_rec":
+                      case "model":
+                      case "custom_recognition":
+                      case "custom_recognition_param":
+                        return (val2) => {
+                          sub_target.__json[sub_key] = val2;
+                          return sub_self;
+                        };
+                      case "roi":
+                        return (...val2) => {
+                          sub_target.__json[sub_key] = val2.length === 4 ? val2 : val2[0];
+                          return sub_self;
+                        };
+                      case "roi_offset":
+                      case "template":
+                      case "threshold":
+                      case "lower":
+                      case "upper":
+                      case "expected":
+                      case "replace":
+                      case "labels":
+                        return (...val2) => {
+                          sub_target.__json[sub_key] = val2;
+                          return sub_self;
+                        };
+                    }
+                    return null;
+                  }
+                }
+              );
+              return sub_self;
+            };
+          case "action":
+            return (val) => {
+              target.__json[key] = val;
+              const sub_self = new Proxy(
+                { __json: {} },
+                {
+                  get(sub_target, sub_key) {
+                    switch (sub_key) {
+                      case "done":
+                        Object.assign(target.__json, sub_target.__json);
+                        return self;
+                      case "key":
+                      case "input_text":
+                      case "package":
+                      case "custom_action":
+                      case "custom_action_param":
+                        return (val2) => {
+                          sub_target.__json[sub_key] = val2;
+                          return sub_self;
+                        };
+                      case "target":
+                      case "begin_target":
+                      case "end_target":
+                        return (...val2) => {
+                          sub_target.__json[sub_key] = val2.length === 4 ? val2 : val2[0];
+                          return sub_self;
+                        };
+                      case "target_offset":
+                      case "begin_offset":
+                      case "end_offset":
+                        return (...val2) => {
+                          sub_target.__json[sub_key] = val2;
+                          return sub_self;
+                        };
+                    }
+                    return null;
+                  }
+                }
+              );
+              return sub_self;
+            };
+          case "rate_limit":
+          case "timeout":
+          case "inverse":
+          case "enabled":
+          case "pre_delay":
+          case "post_delay":
+          case "focus":
+            return (val) => {
+              target.__json[key] = val;
+              return self;
+            };
+          case "next":
+          case "interrupt":
+          case "on_error":
+            return (...val) => {
+              target.__json[key] = val;
+              return self;
+            };
+          case "pre_wait_freezes":
+          case "post_wait_freezes": {
+            const sub_self = new Proxy(
+              { __json: {} },
+              {
+                get(sub_target, sub_key) {
+                  switch (sub_key) {
+                    case "done":
+                      target.__json[key] = sub_target.__json;
+                      return self;
+                    case "time":
+                    case "threshold":
+                    case "method":
+                    case "rate_limit":
+                      return (val) => {
+                        sub_target.__json[sub_key] = val;
+                        return sub_self;
+                      };
+                    case "target":
+                      return (...val) => {
+                        sub_target.__json[sub_key] = val.length === 4 ? val : val[0];
+                        return sub_self;
+                      };
+                    case "target_offset":
+                      return (...val) => {
+                        sub_target.__json[sub_key] = val;
+                        return sub_self;
+                      };
+                  }
+                  return null;
+                }
+              }
+            );
+            return sub_self;
+          }
+        }
+        return null;
+      }
+    }
+  );
+  return self;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdbController,
+  Context,
+  ControllerBase,
+  CustomController,
+  CustomControllerActor,
+  CustomControllerActorDefaultImpl,
+  DbgController,
+  Global,
+  Pi,
+  Resource,
+  ResourceBase,
+  Tasker,
+  TaskerBase,
+  Win32Controller,
+  api,
+  pp
+});