@uipath/agent-tool 1.201.0-preview.115 → 1.201.0-preview.121

package/dist/packager-tool-fhrpdder.js

@@ -0,0 +1,4492 @@
+import {
+  AgentProjectService
+} from "./packager-tool-wzknj3dr.js";
+import {
+  PersonalWorkspacesApi,
+  createApiClient,
+  findSolutionFile,
+  readUipxFile,
+  updateSolutionFile,
+  updateUipxSolutionId
+} from "./packager-tool-bpegrcj1.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-5xdkh3vm.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-gkvdytpj.js";
+import {
+  addSdkUserAgentHeader,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader
+} from "./packager-tool-nsrs2tm5.js";
+import {
+  getFileSystem
+} from "./packager-tool-yv3rvyas.js";
+import {
+  zipSync
+} from "./packager-tool-b098y4a2.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./packager-tool-wckvcay0.js";
+
+// ../../node_modules/adm-zip/util/constants.js
+var require_constants = __commonJS((exports, module) => {
+  module.exports = {
+    LOCHDR: 30,
+    LOCSIG: 67324752,
+    LOCVER: 4,
+    LOCFLG: 6,
+    LOCHOW: 8,
+    LOCTIM: 10,
+    LOCCRC: 14,
+    LOCSIZ: 18,
+    LOCLEN: 22,
+    LOCNAM: 26,
+    LOCEXT: 28,
+    EXTSIG: 134695760,
+    EXTHDR: 16,
+    EXTCRC: 4,
+    EXTSIZ: 8,
+    EXTLEN: 12,
+    CENHDR: 46,
+    CENSIG: 33639248,
+    CENVEM: 4,
+    CENVER: 6,
+    CENFLG: 8,
+    CENHOW: 10,
+    CENTIM: 12,
+    CENCRC: 16,
+    CENSIZ: 20,
+    CENLEN: 24,
+    CENNAM: 28,
+    CENEXT: 30,
+    CENCOM: 32,
+    CENDSK: 34,
+    CENATT: 36,
+    CENATX: 38,
+    CENOFF: 42,
+    ENDHDR: 22,
+    ENDSIG: 101010256,
+    ENDSUB: 8,
+    ENDTOT: 10,
+    ENDSIZ: 12,
+    ENDOFF: 16,
+    ENDCOM: 20,
+    END64HDR: 20,
+    END64SIG: 117853008,
+    END64START: 4,
+    END64OFF: 8,
+    END64NUMDISKS: 16,
+    ZIP64SIG: 101075792,
+    ZIP64HDR: 56,
+    ZIP64LEAD: 12,
+    ZIP64SIZE: 4,
+    ZIP64VEM: 12,
+    ZIP64VER: 14,
+    ZIP64DSK: 16,
+    ZIP64DSKDIR: 20,
+    ZIP64SUB: 24,
+    ZIP64TOT: 32,
+    ZIP64SIZB: 40,
+    ZIP64OFF: 48,
+    ZIP64EXTRA: 56,
+    STORED: 0,
+    SHRUNK: 1,
+    REDUCED1: 2,
+    REDUCED2: 3,
+    REDUCED3: 4,
+    REDUCED4: 5,
+    IMPLODED: 6,
+    DEFLATED: 8,
+    ENHANCED_DEFLATED: 9,
+    PKWARE: 10,
+    BZIP2: 12,
+    LZMA: 14,
+    IBM_TERSE: 18,
+    IBM_LZ77: 19,
+    AES_ENCRYPT: 99,
+    FLG_ENC: 1,
+    FLG_COMP1: 2,
+    FLG_COMP2: 4,
+    FLG_DESC: 8,
+    FLG_ENH: 16,
+    FLG_PATCH: 32,
+    FLG_STR: 64,
+    FLG_EFS: 2048,
+    FLG_MSK: 4096,
+    FILE: 2,
+    BUFFER: 1,
+    NONE: 0,
+    EF_ID: 0,
+    EF_SIZE: 2,
+    ID_ZIP64: 1,
+    ID_AVINFO: 7,
+    ID_PFS: 8,
+    ID_OS2: 9,
+    ID_NTFS: 10,
+    ID_OPENVMS: 12,
+    ID_UNIX: 13,
+    ID_FORK: 14,
+    ID_PATCH: 15,
+    ID_X509_PKCS7: 20,
+    ID_X509_CERTID_F: 21,
+    ID_X509_CERTID_C: 22,
+    ID_STRONGENC: 23,
+    ID_RECORD_MGT: 24,
+    ID_X509_PKCS7_RL: 25,
+    ID_IBM1: 101,
+    ID_IBM2: 102,
+    ID_POSZIP: 18064,
+    EF_ZIP64_OR_32: 4294967295,
+    EF_ZIP64_OR_16: 65535,
+    EF_ZIP64_SUNCOMP: 0,
+    EF_ZIP64_SCOMP: 8,
+    EF_ZIP64_RHO: 16,
+    EF_ZIP64_DSN: 24
+  };
+});
+
+// ../../node_modules/adm-zip/util/errors.js
+var require_errors = __commonJS((exports) => {
+  var errors = {
+    INVALID_LOC: "Invalid LOC header (bad signature)",
+    INVALID_CEN: "Invalid CEN header (bad signature)",
+    INVALID_END: "Invalid END header (bad signature)",
+    DESCRIPTOR_NOT_EXIST: "No descriptor present",
+    DESCRIPTOR_UNKNOWN: "Unknown descriptor format",
+    DESCRIPTOR_FAULTY: "Descriptor data is malformed",
+    NO_DATA: "Nothing to decompress",
+    BAD_CRC: "CRC32 checksum failed {0}",
+    FILE_IN_THE_WAY: "There is a file in the way: {0}",
+    UNKNOWN_METHOD: "Invalid/unsupported compression method",
+    AVAIL_DATA: "inflate::Available inflate data did not terminate",
+    INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+    TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
+    INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
+    INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
+    INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
+    INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
+    INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
+    INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
+    INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
+    CANT_EXTRACT_FILE: "Could not extract the file",
+    CANT_OVERRIDE: "Target file already exists",
+    DISK_ENTRY_TOO_LARGE: "Number of disk entries is too large",
+    NO_ZIP: "No zip file was loaded",
+    NO_ENTRY: "Entry doesn't exist",
+    DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
+    FILE_NOT_FOUND: 'File not found: "{0}"',
+    NOT_IMPLEMENTED: "Not implemented",
+    INVALID_FILENAME: "Invalid filename",
+    INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
+    INVALID_PASS_PARAM: "Incompatible password parameter",
+    WRONG_PASSWORD: "Wrong Password",
+    COMMENT_TOO_LONG: "Comment is too long",
+    EXTRA_FIELD_PARSE_ERROR: "Extra field parsing error"
+  };
+  function E(message) {
+    return function(...args) {
+      if (args.length) {
+        message = message.replace(/\{(\d)\}/g, (_, n) => args[n] || "");
+      }
+      return new Error("ADM-ZIP: " + message);
+    };
+  }
+  for (const msg of Object.keys(errors)) {
+    exports[msg] = E(errors[msg]);
+  }
+});
+
+// ../../node_modules/adm-zip/util/utils.js
+var require_utils = __commonJS((exports, module) => {
+  var fsystem = __require("fs");
+  var pth = __require("path");
+  var Constants = require_constants();
+  var Errors = require_errors();
+  var isWin = typeof process === "object" && process.platform === "win32";
+  var is_Obj = (obj) => typeof obj === "object" && obj !== null;
+  var crcTable = new Uint32Array(256).map((t, c) => {
+    for (let k = 0;k < 8; k++) {
+      if ((c & 1) !== 0) {
+        c = 3988292384 ^ c >>> 1;
+      } else {
+        c >>>= 1;
+      }
+    }
+    return c >>> 0;
+  });
+  function Utils(opts) {
+    this.sep = pth.sep;
+    this.fs = fsystem;
+    if (is_Obj(opts)) {
+      if (is_Obj(opts.fs) && typeof opts.fs.statSync === "function") {
+        this.fs = opts.fs;
+      }
+    }
+  }
+  module.exports = Utils;
+  Utils.prototype.makeDir = function(folder) {
+    const self = this;
+    function mkdirSync(fpath) {
+      let resolvedPath = fpath.split(self.sep)[0];
+      fpath.split(self.sep).forEach(function(name) {
+        if (!name || name.substr(-1, 1) === ":")
+          return;
+        resolvedPath += self.sep + name;
+        var stat;
+        try {
+          stat = self.fs.statSync(resolvedPath);
+        } catch (e) {
+          if (e.message && e.message.startsWith("ENOENT")) {
+            self.fs.mkdirSync(resolvedPath);
+          } else {
+            throw e;
+          }
+        }
+        if (stat && stat.isFile())
+          throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
+      });
+    }
+    mkdirSync(folder);
+  };
+  Utils.prototype.writeFileTo = function(path, content, overwrite, attr) {
+    const self = this;
+    if (self.fs.existsSync(path)) {
+      if (!overwrite)
+        return false;
+      var stat = self.fs.statSync(path);
+      if (stat.isDirectory()) {
+        return false;
+      }
+    }
+    var folder = pth.dirname(path);
+    if (!self.fs.existsSync(folder)) {
+      self.makeDir(folder);
+    }
+    var fd;
+    try {
+      fd = self.fs.openSync(path, "w", 438);
+    } catch (e) {
+      self.fs.chmodSync(path, 438);
+      fd = self.fs.openSync(path, "w", 438);
+    }
+    if (fd) {
+      try {
+        self.fs.writeSync(fd, content, 0, content.length, 0);
+      } finally {
+        self.fs.closeSync(fd);
+      }
+    }
+    self.fs.chmodSync(path, attr || 438);
+    return true;
+  };
+  Utils.prototype.writeFileToAsync = function(path, content, overwrite, attr, callback) {
+    if (typeof attr === "function") {
+      callback = attr;
+      attr = undefined;
+    }
+    const self = this;
+    self.fs.exists(path, function(exist) {
+      if (exist && !overwrite)
+        return callback(false);
+      self.fs.stat(path, function(err, stat) {
+        if (exist && stat && stat.isDirectory()) {
+          return callback(false);
+        }
+        var folder = pth.dirname(path);
+        self.fs.exists(folder, function(exists) {
+          if (!exists) {
+            try {
+              self.makeDir(folder);
+            } catch (e) {
+              return callback(false);
+            }
+          }
+          const writeToFd = function(fd) {
+            self.fs.write(fd, content, 0, content.length, 0, function(writeErr) {
+              self.fs.close(fd, function() {
+                if (writeErr)
+                  return callback(false);
+                self.fs.chmod(path, attr || 438, function() {
+                  callback(true);
+                });
+              });
+            });
+          };
+          self.fs.open(path, "w", 438, function(err2, fd) {
+            if (err2) {
+              self.fs.chmod(path, 438, function() {
+                self.fs.open(path, "w", 438, function(retryErr, fd2) {
+                  if (retryErr || !fd2)
+                    return callback(false);
+                  writeToFd(fd2);
+                });
+              });
+            } else if (fd) {
+              writeToFd(fd);
+            } else {
+              callback(false);
+            }
+          });
+        });
+      });
+    });
+  };
+  Utils.prototype.findFiles = function(path) {
+    const self = this;
+    function findSync(dir, pattern, recursive, visited) {
+      if (typeof pattern === "boolean") {
+        recursive = pattern;
+        pattern = undefined;
+      }
+      let files = [];
+      self.fs.readdirSync(dir).forEach(function(file) {
+        const path2 = pth.join(dir, file);
+        const stat = self.fs.statSync(path2);
+        if (!pattern || pattern.test(path2)) {
+          files.push(pth.normalize(path2) + (stat.isDirectory() ? self.sep : ""));
+        }
+        if (stat.isDirectory() && recursive) {
+          const realDir = self.fs.realpathSync(path2);
+          if (!visited.has(realDir)) {
+            visited.add(realDir);
+            files = files.concat(findSync(path2, pattern, recursive, visited));
+          }
+        }
+      });
+      return files;
+    }
+    return findSync(path, undefined, true, new Set([self.fs.realpathSync(path)]));
+  };
+  Utils.prototype.findFilesAsync = function(dir, cb) {
+    const self = this;
+    const results = [];
+    let finished = false;
+    const finish = function(err) {
+      if (finished)
+        return;
+      finished = true;
+      cb(err, err ? undefined : results);
+    };
+    const walk = function(dir2, visited, done) {
+      self.fs.readdir(dir2, function(err, list) {
+        if (err)
+          return done(err);
+        let pending = list.length;
+        if (!pending)
+          return done();
+        list.forEach(function(name) {
+          const file = pth.join(dir2, name);
+          self.fs.stat(file, function(err2, stat) {
+            if (err2)
+              return done(err2);
+            if (!stat) {
+              if (!--pending)
+                done();
+              return;
+            }
+            results.push(pth.normalize(file) + (stat.isDirectory() ? self.sep : ""));
+            if (!stat.isDirectory()) {
+              if (!--pending)
+                done();
+              return;
+            }
+            self.fs.realpath(file, function(err3, realDir) {
+              if (err3)
+                return done(err3);
+              if (visited.has(realDir)) {
+                if (!--pending)
+                  done();
+                return;
+              }
+              visited.add(realDir);
+              walk(file, visited, function(err4) {
+                if (err4)
+                  return done(err4);
+                if (!--pending)
+                  done();
+              });
+            });
+          });
+        });
+      });
+    };
+    self.fs.realpath(dir, function(err, realDir) {
+      if (err)
+        return finish(err);
+      walk(dir, new Set([realDir]), finish);
+    });
+  };
+  Utils.prototype.getAttributes = function() {};
+  Utils.prototype.setAttributes = function() {};
+  Utils.crc32update = function(crc, byte) {
+    return crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
+  };
+  Utils.crc32 = function(buf) {
+    if (typeof buf === "string") {
+      buf = Buffer.from(buf, "utf8");
+    }
+    let len = buf.length;
+    let crc = ~0;
+    for (let off = 0;off < len; )
+      crc = Utils.crc32update(crc, buf[off++]);
+    return ~crc >>> 0;
+  };
+  Utils.methodToString = function(method) {
+    switch (method) {
+      case Constants.STORED:
+        return "STORED (" + method + ")";
+      case Constants.DEFLATED:
+        return "DEFLATED (" + method + ")";
+      default:
+        return "UNSUPPORTED (" + method + ")";
+    }
+  };
+  Utils.canonical = function(path) {
+    if (!path)
+      return "";
+    const safeSuffix = pth.posix.normalize("/" + path.split("\\").join("/"));
+    return pth.join(".", safeSuffix);
+  };
+  Utils.zipnamefix = function(path) {
+    if (!path)
+      return "";
+    const safeSuffix = pth.posix.normalize("/" + path.split("\\").join("/"));
+    return pth.posix.join(".", safeSuffix);
+  };
+  Utils.findLast = function(arr, callback) {
+    if (!Array.isArray(arr))
+      throw new TypeError("arr is not array");
+    const len = arr.length >>> 0;
+    for (let i = len - 1;i >= 0; i--) {
+      if (callback(arr[i], i, arr)) {
+        return arr[i];
+      }
+    }
+    return;
+  };
+  Utils.sanitize = function(prefix, name) {
+    prefix = pth.resolve(pth.normalize(prefix));
+    var parts = name.split("/");
+    for (var i = 0, l = parts.length;i < l; i++) {
+      var path = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
+      if (path === prefix || path.startsWith(prefix + pth.sep)) {
+        return path;
+      }
+    }
+    return pth.normalize(pth.join(prefix, pth.basename(name)));
+  };
+  Utils.toBuffer = function toBuffer(input, encoder) {
+    if (Buffer.isBuffer(input)) {
+      return input;
+    } else if (input instanceof Uint8Array) {
+      return Buffer.from(input);
+    } else {
+      return typeof input === "string" ? encoder(input) : Buffer.alloc(0);
+    }
+  };
+  Utils.readBigUInt64LE = function(buffer, index) {
+    const lo = buffer.readUInt32LE(index);
+    const hi = buffer.readUInt32LE(index + 4);
+    return hi * 4294967296 + lo;
+  };
+  Utils.writeBigUInt64LE = function(buffer, value, index) {
+    const lo = value >>> 0;
+    const hi = Math.floor(value / 4294967296) >>> 0;
+    buffer.writeUInt32LE(lo, index);
+    buffer.writeUInt32LE(hi, index + 4);
+  };
+  Utils.fromDOS2Date = function(val) {
+    return new Date((val >> 25 & 127) + 1980, Math.max((val >> 21 & 15) - 1, 0), Math.max(val >> 16 & 31, 1), val >> 11 & 31, val >> 5 & 63, (val & 31) << 1);
+  };
+  Utils.fromDate2DOS = function(val) {
+    let date = 0;
+    let time = 0;
+    if (val.getFullYear() > 1979) {
+      date = (val.getFullYear() - 1980 & 127) << 9 | val.getMonth() + 1 << 5 | val.getDate();
+      time = val.getHours() << 11 | val.getMinutes() << 5 | val.getSeconds() >> 1;
+    }
+    return date << 16 | time;
+  };
+  Utils.isWin = isWin;
+  Utils.crcTable = crcTable;
+});
+
+// ../../node_modules/adm-zip/util/fattr.js
+var require_fattr = __commonJS((exports, module) => {
+  var pth = __require("path");
+  module.exports = function(path, { fs }) {
+    var _path = path || "", _obj = newAttr(), _stat = null;
+    function newAttr() {
+      return {
+        directory: false,
+        readonly: false,
+        hidden: false,
+        executable: false,
+        mtime: 0,
+        atime: 0
+      };
+    }
+    if (_path && fs.existsSync(_path)) {
+      _stat = fs.statSync(_path);
+      _obj.directory = _stat.isDirectory();
+      _obj.mtime = _stat.mtime;
+      _obj.atime = _stat.atime;
+      _obj.executable = (73 & _stat.mode) !== 0;
+      _obj.readonly = (128 & _stat.mode) === 0;
+      _obj.hidden = pth.basename(_path)[0] === ".";
+    } else {
+      console.warn("Invalid path: " + _path);
+    }
+    return {
+      get directory() {
+        return _obj.directory;
+      },
+      get readOnly() {
+        return _obj.readonly;
+      },
+      get hidden() {
+        return _obj.hidden;
+      },
+      get mtime() {
+        return _obj.mtime;
+      },
+      get atime() {
+        return _obj.atime;
+      },
+      get executable() {
+        return _obj.executable;
+      },
+      decodeAttributes: function() {},
+      encodeAttributes: function() {},
+      toJSON: function() {
+        return {
+          path: _path,
+          isDirectory: _obj.directory,
+          isReadOnly: _obj.readonly,
+          isHidden: _obj.hidden,
+          isExecutable: _obj.executable,
+          mTime: _obj.mtime,
+          aTime: _obj.atime
+        };
+      },
+      toString: function() {
+        return JSON.stringify(this.toJSON(), null, "\t");
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/util/decoder.js
+var require_decoder = __commonJS((exports, module) => {
+  module.exports = {
+    efs: true,
+    encode: (data) => Buffer.from(data, "utf8"),
+    decode: (data) => data.toString("utf8")
+  };
+});
+
+// ../../node_modules/adm-zip/util/index.js
+var require_util = __commonJS((exports, module) => {
+  module.exports = require_utils();
+  module.exports.Constants = require_constants();
+  module.exports.Errors = require_errors();
+  module.exports.FileAttr = require_fattr();
+  module.exports.decoder = require_decoder();
+});
+
+// ../../node_modules/adm-zip/headers/entryHeader.js
+var require_entryHeader = __commonJS((exports, module) => {
+  var Utils = require_util();
+  var Constants = Utils.Constants;
+  module.exports = function() {
+    var _verMade = 20, _version = 10, _flags = 0, _method = 0, _time = 0, _crc = 0, _compressedSize = 0, _size = 0, _fnameLen = 0, _extraLen = 0, _comLen = 0, _diskStart = 0, _inattr = 0, _attr = 0, _offset = 0;
+    _verMade |= Utils.isWin ? 2560 : 768;
+    _flags |= Constants.FLG_EFS;
+    const _localHeader = {
+      extraLen: 0
+    };
+    const uint32 = (val) => Math.max(0, val) >>> 0;
+    const uint16 = (val) => Math.max(0, val) & 65535;
+    const uint8 = (val) => Math.max(0, val) & 255;
+    _time = Utils.fromDate2DOS(new Date);
+    return {
+      get made() {
+        return _verMade;
+      },
+      set made(val) {
+        _verMade = val;
+      },
+      get version() {
+        return _version;
+      },
+      set version(val) {
+        _version = val;
+      },
+      get flags() {
+        return _flags;
+      },
+      set flags(val) {
+        _flags = val;
+      },
+      get flags_efs() {
+        return (_flags & Constants.FLG_EFS) > 0;
+      },
+      set flags_efs(val) {
+        if (val) {
+          _flags |= Constants.FLG_EFS;
+        } else {
+          _flags &= ~Constants.FLG_EFS;
+        }
+      },
+      get flags_desc() {
+        return (_flags & Constants.FLG_DESC) > 0;
+      },
+      set flags_desc(val) {
+        if (val) {
+          _flags |= Constants.FLG_DESC;
+        } else {
+          _flags &= ~Constants.FLG_DESC;
+        }
+      },
+      get method() {
+        return _method;
+      },
+      set method(val) {
+        switch (val) {
+          case Constants.STORED:
+            this.version = 10;
+            break;
+          case Constants.DEFLATED:
+          default:
+            this.version = 20;
+        }
+        _method = val;
+      },
+      get time() {
+        return Utils.fromDOS2Date(this.timeval);
+      },
+      set time(val) {
+        val = new Date(val);
+        this.timeval = Utils.fromDate2DOS(val);
+      },
+      get timeval() {
+        return _time;
+      },
+      set timeval(val) {
+        _time = uint32(val);
+      },
+      get timeHighByte() {
+        return uint8(_time >>> 8);
+      },
+      get crc() {
+        return _crc;
+      },
+      set crc(val) {
+        _crc = uint32(val);
+      },
+      get compressedSize() {
+        return _compressedSize;
+      },
+      set compressedSize(val) {
+        _compressedSize = uint32(val);
+      },
+      get size() {
+        return _size;
+      },
+      set size(val) {
+        _size = uint32(val);
+      },
+      get fileNameLength() {
+        return _fnameLen;
+      },
+      set fileNameLength(val) {
+        _fnameLen = val;
+      },
+      get extraLength() {
+        return _extraLen;
+      },
+      set extraLength(val) {
+        _extraLen = val;
+      },
+      get extraLocalLength() {
+        return _localHeader.extraLen;
+      },
+      set extraLocalLength(val) {
+        _localHeader.extraLen = val;
+      },
+      get commentLength() {
+        return _comLen;
+      },
+      set commentLength(val) {
+        _comLen = val;
+      },
+      get diskNumStart() {
+        return _diskStart;
+      },
+      set diskNumStart(val) {
+        _diskStart = uint32(val);
+      },
+      get inAttr() {
+        return _inattr;
+      },
+      set inAttr(val) {
+        _inattr = uint32(val);
+      },
+      get attr() {
+        return _attr;
+      },
+      set attr(val) {
+        _attr = uint32(val);
+      },
+      get fileAttr() {
+        return (_attr || 0) >> 16 & 4095;
+      },
+      get offset() {
+        return _offset;
+      },
+      set offset(val) {
+        _offset = uint32(val);
+      },
+      get encrypted() {
+        return (_flags & Constants.FLG_ENC) === Constants.FLG_ENC;
+      },
+      get centralHeaderSize() {
+        return Constants.CENHDR + _fnameLen + _extraLen + _comLen;
+      },
+      get realDataOffset() {
+        return _offset + Constants.LOCHDR + _localHeader.fnameLen + _localHeader.extraLen;
+      },
+      get localHeader() {
+        return _localHeader;
+      },
+      loadLocalHeaderFromBinary: function(input) {
+        var data = input.slice(_offset, _offset + Constants.LOCHDR);
+        if (data.readUInt32LE(0) !== Constants.LOCSIG) {
+          throw Utils.Errors.INVALID_LOC();
+        }
+        _localHeader.version = data.readUInt16LE(Constants.LOCVER);
+        _localHeader.flags = data.readUInt16LE(Constants.LOCFLG);
+        _localHeader.flags_desc = (_localHeader.flags & Constants.FLG_DESC) > 0;
+        _localHeader.method = data.readUInt16LE(Constants.LOCHOW);
+        _localHeader.time = data.readUInt32LE(Constants.LOCTIM);
+        _localHeader.crc = data.readUInt32LE(Constants.LOCCRC);
+        _localHeader.compressedSize = data.readUInt32LE(Constants.LOCSIZ);
+        _localHeader.size = data.readUInt32LE(Constants.LOCLEN);
+        _localHeader.fnameLen = data.readUInt16LE(Constants.LOCNAM);
+        _localHeader.extraLen = data.readUInt16LE(Constants.LOCEXT);
+        const extraStart = _offset + Constants.LOCHDR + _localHeader.fnameLen;
+        const extraEnd = extraStart + _localHeader.extraLen;
+        return input.slice(extraStart, extraEnd);
+      },
+      loadFromBinary: function(data) {
+        if (data.length !== Constants.CENHDR || data.readUInt32LE(0) !== Constants.CENSIG) {
+          throw Utils.Errors.INVALID_CEN();
+        }
+        _verMade = data.readUInt16LE(Constants.CENVEM);
+        _version = data.readUInt16LE(Constants.CENVER);
+        _flags = data.readUInt16LE(Constants.CENFLG);
+        _method = data.readUInt16LE(Constants.CENHOW);
+        _time = data.readUInt32LE(Constants.CENTIM);
+        _crc = data.readUInt32LE(Constants.CENCRC);
+        _compressedSize = data.readUInt32LE(Constants.CENSIZ);
+        _size = data.readUInt32LE(Constants.CENLEN);
+        _fnameLen = data.readUInt16LE(Constants.CENNAM);
+        _extraLen = data.readUInt16LE(Constants.CENEXT);
+        _comLen = data.readUInt16LE(Constants.CENCOM);
+        _diskStart = data.readUInt16LE(Constants.CENDSK);
+        _inattr = data.readUInt16LE(Constants.CENATT);
+        _attr = data.readUInt32LE(Constants.CENATX);
+        _offset = data.readUInt32LE(Constants.CENOFF);
+      },
+      localHeaderToBinary: function() {
+        var data = Buffer.alloc(Constants.LOCHDR);
+        data.writeUInt32LE(Constants.LOCSIG, 0);
+        data.writeUInt16LE(_version, Constants.LOCVER);
+        data.writeUInt16LE(_flags & ~Constants.FLG_DESC, Constants.LOCFLG);
+        data.writeUInt16LE(_method, Constants.LOCHOW);
+        data.writeUInt32LE(_time, Constants.LOCTIM);
+        data.writeUInt32LE(_crc, Constants.LOCCRC);
+        data.writeUInt32LE(_compressedSize, Constants.LOCSIZ);
+        data.writeUInt32LE(_size, Constants.LOCLEN);
+        data.writeUInt16LE(_fnameLen, Constants.LOCNAM);
+        data.writeUInt16LE(_localHeader.extraLen, Constants.LOCEXT);
+        return data;
+      },
+      centralHeaderToBinary: function() {
+        var data = Buffer.alloc(Constants.CENHDR + _fnameLen + _extraLen + _comLen);
+        data.writeUInt32LE(Constants.CENSIG, 0);
+        data.writeUInt16LE(_verMade, Constants.CENVEM);
+        data.writeUInt16LE(_version, Constants.CENVER);
+        data.writeUInt16LE(_flags & ~Constants.FLG_DESC, Constants.CENFLG);
+        data.writeUInt16LE(_method, Constants.CENHOW);
+        data.writeUInt32LE(_time, Constants.CENTIM);
+        data.writeUInt32LE(_crc, Constants.CENCRC);
+        data.writeUInt32LE(_compressedSize, Constants.CENSIZ);
+        data.writeUInt32LE(_size, Constants.CENLEN);
+        data.writeUInt16LE(_fnameLen, Constants.CENNAM);
+        data.writeUInt16LE(_extraLen, Constants.CENEXT);
+        data.writeUInt16LE(_comLen, Constants.CENCOM);
+        data.writeUInt16LE(_diskStart, Constants.CENDSK);
+        data.writeUInt16LE(_inattr, Constants.CENATT);
+        data.writeUInt32LE(_attr, Constants.CENATX);
+        data.writeUInt32LE(_offset, Constants.CENOFF);
+        return data;
+      },
+      toJSON: function() {
+        const bytes = function(nr) {
+          return nr + " bytes";
+        };
+        return {
+          made: _verMade,
+          version: _version,
+          flags: _flags,
+          method: Utils.methodToString(_method),
+          time: this.time,
+          crc: "0x" + _crc.toString(16).toUpperCase(),
+          compressedSize: bytes(_compressedSize),
+          size: bytes(_size),
+          fileNameLength: bytes(_fnameLen),
+          extraLength: bytes(_extraLen),
+          commentLength: bytes(_comLen),
+          diskNumStart: _diskStart,
+          inAttr: _inattr,
+          attr: _attr,
+          offset: _offset,
+          centralHeaderSize: bytes(Constants.CENHDR + _fnameLen + _extraLen + _comLen)
+        };
+      },
+      toString: function() {
+        return JSON.stringify(this.toJSON(), null, "\t");
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/headers/mainHeader.js
+var require_mainHeader = __commonJS((exports, module) => {
+  var Utils = require_util();
+  var Constants = Utils.Constants;
+  module.exports = function() {
+    var _volumeEntries = 0, _totalEntries = 0, _size = 0, _offset = 0, _commentLength = 0;
+    const needsZip64 = () => _volumeEntries > Constants.EF_ZIP64_OR_16 || _totalEntries > Constants.EF_ZIP64_OR_16 || _size > Constants.EF_ZIP64_OR_32 || _offset > Constants.EF_ZIP64_OR_32;
+    return {
+      get diskEntries() {
+        return _volumeEntries;
+      },
+      set diskEntries(val) {
+        _volumeEntries = _totalEntries = val;
+      },
+      get totalEntries() {
+        return _totalEntries;
+      },
+      set totalEntries(val) {
+        _totalEntries = _volumeEntries = val;
+      },
+      get size() {
+        return _size;
+      },
+      set size(val) {
+        _size = val;
+      },
+      get offset() {
+        return _offset;
+      },
+      set offset(val) {
+        _offset = val;
+      },
+      get commentLength() {
+        return _commentLength;
+      },
+      set commentLength(val) {
+        _commentLength = val;
+      },
+      get mainHeaderSize() {
+        return (needsZip64() ? Constants.ZIP64HDR + Constants.END64HDR : 0) + Constants.ENDHDR + _commentLength;
+      },
+      loadFromBinary: function(data) {
+        if ((data.length !== Constants.ENDHDR || data.readUInt32LE(0) !== Constants.ENDSIG) && (data.length < Constants.ZIP64HDR || data.readUInt32LE(0) !== Constants.ZIP64SIG)) {
+          throw Utils.Errors.INVALID_END();
+        }
+        if (data.readUInt32LE(0) === Constants.ENDSIG) {
+          _volumeEntries = data.readUInt16LE(Constants.ENDSUB);
+          _totalEntries = data.readUInt16LE(Constants.ENDTOT);
+          _size = data.readUInt32LE(Constants.ENDSIZ);
+          _offset = data.readUInt32LE(Constants.ENDOFF);
+          _commentLength = data.readUInt16LE(Constants.ENDCOM);
+        } else {
+          _volumeEntries = Utils.readBigUInt64LE(data, Constants.ZIP64SUB);
+          _totalEntries = Utils.readBigUInt64LE(data, Constants.ZIP64TOT);
+          _size = Utils.readBigUInt64LE(data, Constants.ZIP64SIZB);
+          _offset = Utils.readBigUInt64LE(data, Constants.ZIP64OFF);
+          _commentLength = 0;
+        }
+      },
+      toBinary: function() {
+        if (!needsZip64()) {
+          var b = Buffer.alloc(Constants.ENDHDR + _commentLength);
+          b.writeUInt32LE(Constants.ENDSIG, 0);
+          b.writeUInt32LE(0, 4);
+          b.writeUInt16LE(_volumeEntries, Constants.ENDSUB);
+          b.writeUInt16LE(_totalEntries, Constants.ENDTOT);
+          b.writeUInt32LE(_size, Constants.ENDSIZ);
+          b.writeUInt32LE(_offset, Constants.ENDOFF);
+          b.writeUInt16LE(_commentLength, Constants.ENDCOM);
+          b.fill(" ", Constants.ENDHDR);
+          return b;
+        }
+        var b = Buffer.alloc(this.mainHeaderSize);
+        let offset = 0;
+        b.writeUInt32LE(Constants.ZIP64SIG, offset);
+        Utils.writeBigUInt64LE(b, Constants.ZIP64HDR - Constants.ZIP64LEAD, offset + Constants.ZIP64SIZE);
+        b.writeUInt16LE(45, offset + Constants.ZIP64VEM);
+        b.writeUInt16LE(45, offset + Constants.ZIP64VER);
+        b.writeUInt32LE(0, offset + Constants.ZIP64DSK);
+        b.writeUInt32LE(0, offset + Constants.ZIP64DSKDIR);
+        Utils.writeBigUInt64LE(b, _volumeEntries, offset + Constants.ZIP64SUB);
+        Utils.writeBigUInt64LE(b, _totalEntries, offset + Constants.ZIP64TOT);
+        Utils.writeBigUInt64LE(b, _size, offset + Constants.ZIP64SIZB);
+        Utils.writeBigUInt64LE(b, _offset, offset + Constants.ZIP64OFF);
+        const zip64EndOffset = _offset + _size;
+        offset += Constants.ZIP64HDR;
+        b.writeUInt32LE(Constants.END64SIG, offset);
+        b.writeUInt32LE(0, offset + Constants.END64START);
+        Utils.writeBigUInt64LE(b, zip64EndOffset, offset + Constants.END64OFF);
+        b.writeUInt32LE(1, offset + Constants.END64NUMDISKS);
+        offset += Constants.END64HDR;
+        b.writeUInt32LE(Constants.ENDSIG, offset);
+        b.writeUInt32LE(0, offset + 4);
+        b.writeUInt16LE(Math.min(_volumeEntries, Constants.EF_ZIP64_OR_16), offset + Constants.ENDSUB);
+        b.writeUInt16LE(Math.min(_totalEntries, Constants.EF_ZIP64_OR_16), offset + Constants.ENDTOT);
+        b.writeUInt32LE(Math.min(_size, Constants.EF_ZIP64_OR_32), offset + Constants.ENDSIZ);
+        b.writeUInt32LE(Math.min(_offset, Constants.EF_ZIP64_OR_32), offset + Constants.ENDOFF);
+        b.writeUInt16LE(_commentLength, offset + Constants.ENDCOM);
+        b.fill(" ", offset + Constants.ENDHDR);
+        return b;
+      },
+      toJSON: function() {
+        const offset = function(nr, len) {
+          let offs = nr.toString(16).toUpperCase();
+          while (offs.length < len)
+            offs = "0" + offs;
+          return "0x" + offs;
+        };
+        return {
+          diskEntries: _volumeEntries,
+          totalEntries: _totalEntries,
+          size: _size + " bytes",
+          offset: offset(_offset, 4),
+          commentLength: _commentLength
+        };
+      },
+      toString: function() {
+        return JSON.stringify(this.toJSON(), null, "\t");
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/headers/index.js
+var require_headers = __commonJS((exports) => {
+  exports.EntryHeader = require_entryHeader();
+  exports.MainHeader = require_mainHeader();
+});
+
+// ../../node_modules/adm-zip/methods/deflater.js
+var require_deflater = __commonJS((exports, module) => {
+  module.exports = function(inbuf) {
+    var zlib = __require("zlib");
+    var opts = { chunkSize: (parseInt(inbuf.length / 1024) + 1) * 1024 };
+    return {
+      deflate: function() {
+        return zlib.deflateRawSync(inbuf, opts);
+      },
+      deflateAsync: function(callback) {
+        var tmp = zlib.createDeflateRaw(opts), parts = [], total = 0;
+        tmp.on("data", function(data) {
+          parts.push(data);
+          total += data.length;
+        });
+        tmp.on("end", function() {
+          var buf = Buffer.alloc(total), written = 0;
+          buf.fill(0);
+          for (var i = 0;i < parts.length; i++) {
+            var part = parts[i];
+            part.copy(buf, written);
+            written += part.length;
+          }
+          callback && callback(buf);
+        });
+        tmp.end(inbuf);
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/methods/inflater.js
+var require_inflater = __commonJS((exports, module) => {
+  var version = +(process?.versions?.node ?? "").split(".")[0] || 0;
+  module.exports = function(inbuf, expectedLength) {
+    var zlib = __require("zlib");
+    const option = version >= 15 && expectedLength > 0 ? { maxOutputLength: expectedLength } : {};
+    return {
+      inflate: function() {
+        return zlib.inflateRawSync(inbuf, option);
+      },
+      inflateAsync: function(callback) {
+        var tmp = zlib.createInflateRaw(option), parts = [], total = 0;
+        tmp.on("data", function(data) {
+          parts.push(data);
+          total += data.length;
+        });
+        tmp.on("end", function() {
+          var buf = Buffer.alloc(total), written = 0;
+          buf.fill(0);
+          for (var i = 0;i < parts.length; i++) {
+            var part = parts[i];
+            part.copy(buf, written);
+            written += part.length;
+          }
+          callback && callback(buf);
+        });
+        tmp.end(inbuf);
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/methods/zipcrypto.js
+var require_zipcrypto = __commonJS((exports, module) => {
+  var { randomFillSync } = __require("crypto");
+  var Errors = require_errors();
+  var crctable = new Uint32Array(256).map((t, crc) => {
+    for (let j = 0;j < 8; j++) {
+      if ((crc & 1) !== 0) {
+        crc = crc >>> 1 ^ 3988292384;
+      } else {
+        crc >>>= 1;
+      }
+    }
+    return crc >>> 0;
+  });
+  var uMul = (a, b) => Math.imul(a, b) >>> 0;
+  var crc32update = (pCrc32, bval) => {
+    return crctable[(pCrc32 ^ bval) & 255] ^ pCrc32 >>> 8;
+  };
+  var genSalt = () => {
+    if (typeof randomFillSync === "function") {
+      return randomFillSync(Buffer.alloc(12));
+    } else {
+      return genSalt.node();
+    }
+  };
+  genSalt.node = () => {
+    const salt = Buffer.alloc(12);
+    const len = salt.length;
+    for (let i = 0;i < len; i++)
+      salt[i] = Math.random() * 256 & 255;
+    return salt;
+  };
+  var config = {
+    genSalt
+  };
+  function Initkeys(pw) {
+    const pass = Buffer.isBuffer(pw) ? pw : Buffer.from(pw);
+    this.keys = new Uint32Array([305419896, 591751049, 878082192]);
+    for (let i = 0;i < pass.length; i++) {
+      this.updateKeys(pass[i]);
+    }
+  }
+  Initkeys.prototype.updateKeys = function(byteValue) {
+    const keys = this.keys;
+    keys[0] = crc32update(keys[0], byteValue);
+    keys[1] += keys[0] & 255;
+    keys[1] = uMul(keys[1], 134775813) + 1;
+    keys[2] = crc32update(keys[2], keys[1] >>> 24);
+    return byteValue;
+  };
+  Initkeys.prototype.next = function() {
+    const k = (this.keys[2] | 2) >>> 0;
+    return uMul(k, k ^ 1) >> 8 & 255;
+  };
+  function make_decrypter(pwd) {
+    const keys = new Initkeys(pwd);
+    return function(data) {
+      const result = Buffer.alloc(data.length);
+      let pos = 0;
+      for (let c of data) {
+        result[pos++] = keys.updateKeys(c ^ keys.next());
+      }
+      return result;
+    };
+  }
+  function make_encrypter(pwd) {
+    const keys = new Initkeys(pwd);
+    return function(data, result, pos = 0) {
+      if (!result)
+        result = Buffer.alloc(data.length);
+      for (let c of data) {
+        const k = keys.next();
+        result[pos++] = c ^ k;
+        keys.updateKeys(c);
+      }
+      return result;
+    };
+  }
+  function decrypt(data, header, pwd) {
+    if (!data || !Buffer.isBuffer(data) || data.length < 12) {
+      return Buffer.alloc(0);
+    }
+    const decrypter = make_decrypter(pwd);
+    const salt = decrypter(data.slice(0, 12));
+    const verifyByte = (header.flags & 8) === 8 ? header.timeHighByte : header.crc >>> 24;
+    if (salt[11] !== verifyByte) {
+      throw Errors.WRONG_PASSWORD();
+    }
+    return decrypter(data.slice(12));
+  }
+  function _salter(data) {
+    if (Buffer.isBuffer(data) && data.length >= 12) {
+      config.genSalt = function() {
+        return data.slice(0, 12);
+      };
+    } else if (data === "node") {
+      config.genSalt = genSalt.node;
+    } else {
+      config.genSalt = genSalt;
+    }
+  }
+  function encrypt(data, header, pwd, oldlike = false) {
+    if (data == null)
+      data = Buffer.alloc(0);
+    if (!Buffer.isBuffer(data))
+      data = Buffer.from(data.toString());
+    const encrypter = make_encrypter(pwd);
+    const salt = config.genSalt();
+    salt[11] = header.crc >>> 24 & 255;
+    if (oldlike)
+      salt[10] = header.crc >>> 16 & 255;
+    const result = Buffer.alloc(data.length + 12);
+    encrypter(salt, result);
+    return encrypter(data, result, 12);
+  }
+  module.exports = { decrypt, encrypt, _salter };
+});
+
+// ../../node_modules/adm-zip/methods/index.js
+var require_methods = __commonJS((exports) => {
+  exports.Deflater = require_deflater();
+  exports.Inflater = require_inflater();
+  exports.ZipCrypto = require_zipcrypto();
+});
+
+// ../../node_modules/adm-zip/zipEntry.js
+var require_zipEntry = __commonJS((exports, module) => {
+  var Utils = require_util();
+  var Headers = require_headers();
+  var Constants = Utils.Constants;
+  var Methods = require_methods();
+  module.exports = function(options, input) {
+    var _centralHeader = new Headers.EntryHeader, _entryName = Buffer.alloc(0), _comment = Buffer.alloc(0), _isDirectory = false, uncompressedData = null, _extra = Buffer.alloc(0), _extralocal = Buffer.alloc(0), _efs = true;
+    const opts = options;
+    const decoder = typeof opts.decoder === "object" ? opts.decoder : Utils.decoder;
+    _efs = decoder.hasOwnProperty("efs") ? decoder.efs : false;
+    function getCompressedDataFromZip() {
+      if (!input || !(input instanceof Uint8Array)) {
+        return Buffer.alloc(0);
+      }
+      _extralocal = _centralHeader.loadLocalHeaderFromBinary(input);
+      return input.slice(_centralHeader.realDataOffset, _centralHeader.realDataOffset + _centralHeader.compressedSize);
+    }
+    function crc32OK(data) {
+      const expectedCrc = _centralHeader.flags_desc || _centralHeader.localHeader.flags_desc ? _centralHeader.crc : _centralHeader.localHeader.crc;
+      return Utils.crc32(data) === expectedCrc;
+    }
+    function decompress(async, callback, pass) {
+      if (typeof callback === "undefined" && typeof async === "string") {
+        pass = async;
+        async = undefined;
+      }
+      if (_isDirectory) {
+        if (async && callback) {
+          callback(Buffer.alloc(0), Utils.Errors.DIRECTORY_CONTENT_ERROR());
+        }
+        return Buffer.alloc(0);
+      }
+      var compressedData = getCompressedDataFromZip();
+      if (compressedData.length === 0) {
+        if (async && callback)
+          callback(compressedData);
+        return compressedData;
+      }
+      if (_centralHeader.encrypted) {
+        if (typeof pass !== "string" && !Buffer.isBuffer(pass)) {
+          throw Utils.Errors.INVALID_PASS_PARAM();
+        }
+        compressedData = Methods.ZipCrypto.decrypt(compressedData, _centralHeader, pass);
+      }
+      var data;
+      switch (_centralHeader.method) {
+        case Utils.Constants.STORED:
+          data = Buffer.alloc(compressedData.length);
+          compressedData.copy(data);
+          if (!crc32OK(data)) {
+            if (async && callback)
+              callback(data, Utils.Errors.BAD_CRC());
+            throw Utils.Errors.BAD_CRC();
+          } else {
+            if (async && callback)
+              callback(data);
+            return data;
+          }
+        case Utils.Constants.DEFLATED:
+          var inflater = new Methods.Inflater(compressedData, _centralHeader.size);
+          if (!async) {
+            data = inflater.inflate();
+            if (!crc32OK(data)) {
+              throw Utils.Errors.BAD_CRC(`"${decoder.decode(_entryName)}"`);
+            }
+            return data;
+          } else {
+            inflater.inflateAsync(function(result) {
+              if (callback) {
+                if (!crc32OK(result)) {
+                  callback(result, Utils.Errors.BAD_CRC());
+                } else {
+                  callback(result);
+                }
+              }
+            });
+          }
+          break;
+        default:
+          if (async && callback)
+            callback(Buffer.alloc(0), Utils.Errors.UNKNOWN_METHOD());
+          throw Utils.Errors.UNKNOWN_METHOD();
+      }
+    }
+    function compress(async, callback) {
+      if ((!uncompressedData || !uncompressedData.length) && Buffer.isBuffer(input)) {
+        if (async && callback)
+          callback(getCompressedDataFromZip());
+        return getCompressedDataFromZip();
+      }
+      if (uncompressedData.length && !_isDirectory) {
+        var compressedData;
+        switch (_centralHeader.method) {
+          case Utils.Constants.STORED:
+            _centralHeader.compressedSize = _centralHeader.size;
+            compressedData = Buffer.alloc(uncompressedData.length);
+            uncompressedData.copy(compressedData);
+            if (async && callback)
+              callback(compressedData);
+            return compressedData;
+          default:
+          case Utils.Constants.DEFLATED:
+            var deflater = new Methods.Deflater(uncompressedData);
+            if (!async) {
+              var deflated = deflater.deflate();
+              _centralHeader.compressedSize = deflated.length;
+              return deflated;
+            } else {
+              deflater.deflateAsync(function(data) {
+                compressedData = Buffer.alloc(data.length);
+                _centralHeader.compressedSize = data.length;
+                data.copy(compressedData);
+                callback && callback(compressedData);
+              });
+            }
+            deflater = null;
+            break;
+        }
+      } else if (async && callback) {
+        callback(Buffer.alloc(0));
+      } else {
+        return Buffer.alloc(0);
+      }
+    }
+    function readUInt64LE(buffer, offset) {
+      return Utils.readBigUInt64LE(buffer, offset);
+    }
+    function parseExtra(data) {
+      try {
+        var offset = 0;
+        var signature, size, part;
+        while (offset + 4 < data.length) {
+          signature = data.readUInt16LE(offset);
+          offset += 2;
+          size = data.readUInt16LE(offset);
+          offset += 2;
+          part = data.slice(offset, offset + size);
+          offset += size;
+          if (Constants.ID_ZIP64 === signature) {
+            parseZip64ExtendedInformation(part);
+          }
+        }
+      } catch (error) {
+        throw Utils.Errors.EXTRA_FIELD_PARSE_ERROR();
+      }
+    }
+    function parseZip64ExtendedInformation(data) {
+      var size, compressedSize, offset, diskNumStart;
+      if (data.length >= Constants.EF_ZIP64_SCOMP) {
+        size = readUInt64LE(data, Constants.EF_ZIP64_SUNCOMP);
+        if (_centralHeader.size === Constants.EF_ZIP64_OR_32) {
+          _centralHeader.size = size;
+        }
+      }
+      if (data.length >= Constants.EF_ZIP64_RHO) {
+        compressedSize = readUInt64LE(data, Constants.EF_ZIP64_SCOMP);
+        if (_centralHeader.compressedSize === Constants.EF_ZIP64_OR_32) {
+          _centralHeader.compressedSize = compressedSize;
+        }
+      }
+      if (data.length >= Constants.EF_ZIP64_DSN) {
+        offset = readUInt64LE(data, Constants.EF_ZIP64_RHO);
+        if (_centralHeader.offset === Constants.EF_ZIP64_OR_32) {
+          _centralHeader.offset = offset;
+        }
+      }
+      if (data.length >= Constants.EF_ZIP64_DSN + 4) {
+        diskNumStart = data.readUInt32LE(Constants.EF_ZIP64_DSN);
+        if (_centralHeader.diskNumStart === Constants.EF_ZIP64_OR_16) {
+          _centralHeader.diskNumStart = diskNumStart;
+        }
+      }
+    }
+    return {
+      get entryName() {
+        return decoder.decode(_entryName);
+      },
+      get rawEntryName() {
+        return _entryName;
+      },
+      set entryName(val) {
+        _entryName = Utils.toBuffer(val, decoder.encode);
+        var lastChar = _entryName[_entryName.length - 1];
+        _isDirectory = lastChar === 47 || lastChar === 92;
+        _centralHeader.fileNameLength = _entryName.length;
+      },
+      get efs() {
+        if (typeof _efs === "function") {
+          return _efs(this.entryName);
+        } else {
+          return _efs;
+        }
+      },
+      get extra() {
+        return _extra;
+      },
+      set extra(val) {
+        _extra = val;
+        _centralHeader.extraLength = val.length;
+        parseExtra(val);
+      },
+      get comment() {
+        return decoder.decode(_comment);
+      },
+      set comment(val) {
+        _comment = Utils.toBuffer(val, decoder.encode);
+        _centralHeader.commentLength = _comment.length;
+        if (_comment.length > 65535)
+          throw Utils.Errors.COMMENT_TOO_LONG();
+      },
+      get name() {
+        const n = decoder.decode(_entryName);
+        return _isDirectory ? n.replace(/[/\\]$/, "").split("/").pop() : n.split("/").pop();
+      },
+      get isDirectory() {
+        return _isDirectory;
+      },
+      getCompressedData: function() {
+        return compress(false, null);
+      },
+      getCompressedDataAsync: function(callback) {
+        compress(true, callback);
+      },
+      setData: function(value) {
+        uncompressedData = Utils.toBuffer(value, Utils.decoder.encode);
+        if (!_isDirectory && uncompressedData.length) {
+          _centralHeader.size = uncompressedData.length;
+          _centralHeader.method = Utils.Constants.DEFLATED;
+          _centralHeader.crc = Utils.crc32(value);
+          _centralHeader.changed = true;
+        } else {
+          _centralHeader.method = Utils.Constants.STORED;
+        }
+      },
+      getData: function(pass) {
+        if (_centralHeader.changed) {
+          return uncompressedData;
+        } else {
+          return decompress(false, null, pass);
+        }
+      },
+      getDataAsync: function(callback, pass) {
+        if (_centralHeader.changed) {
+          callback(uncompressedData);
+        } else {
+          decompress(true, callback, pass);
+        }
+      },
+      set attr(attr) {
+        _centralHeader.attr = attr;
+      },
+      get attr() {
+        return _centralHeader.attr;
+      },
+      set header(data) {
+        _centralHeader.loadFromBinary(data);
+      },
+      get header() {
+        return _centralHeader;
+      },
+      packCentralHeader: function() {
+        _centralHeader.flags_efs = this.efs;
+        _centralHeader.extraLength = _extra.length;
+        var header = _centralHeader.centralHeaderToBinary();
+        var addpos = Utils.Constants.CENHDR;
+        _entryName.copy(header, addpos);
+        addpos += _entryName.length;
+        _extra.copy(header, addpos);
+        addpos += _centralHeader.extraLength;
+        _comment.copy(header, addpos);
+        return header;
+      },
+      packLocalHeader: function() {
+        let addpos = 0;
+        _centralHeader.flags_efs = this.efs;
+        _centralHeader.extraLocalLength = _extralocal.length;
+        const localHeaderBuf = _centralHeader.localHeaderToBinary();
+        const localHeader = Buffer.alloc(localHeaderBuf.length + _entryName.length + _centralHeader.extraLocalLength);
+        localHeaderBuf.copy(localHeader, addpos);
+        addpos += localHeaderBuf.length;
+        _entryName.copy(localHeader, addpos);
+        addpos += _entryName.length;
+        _extralocal.copy(localHeader, addpos);
+        addpos += _extralocal.length;
+        return localHeader;
+      },
+      toJSON: function() {
+        const bytes = function(nr) {
+          return "<" + (nr && nr.length + " bytes buffer" || "null") + ">";
+        };
+        return {
+          entryName: this.entryName,
+          name: this.name,
+          comment: this.comment,
+          isDirectory: this.isDirectory,
+          header: _centralHeader.toJSON(),
+          compressedData: bytes(input),
+          data: bytes(uncompressedData)
+        };
+      },
+      toString: function() {
+        return JSON.stringify(this.toJSON(), null, "\t");
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/zipFile.js
+var require_zipFile = __commonJS((exports, module) => {
+  var ZipEntry = require_zipEntry();
+  var Headers = require_headers();
+  var Utils = require_util();
+  module.exports = function(inBuffer, options) {
+    var entryList = [], entryTable = Object.create(null), _comment = Buffer.alloc(0), mainHeader = new Headers.MainHeader, loadedEntries = false;
+    var password = null;
+    const temporary = new Set;
+    const opts = options;
+    const { noSort, decoder } = opts;
+    if (inBuffer) {
+      readMainHeader(opts.readEntries);
+    } else {
+      loadedEntries = true;
+    }
+    function makeTemporaryFolders() {
+      const foldersList = new Set;
+      for (const elem of Object.keys(entryTable)) {
+        const elements = elem.split("/");
+        elements.pop();
+        if (!elements.length)
+          continue;
+        for (let i = 0;i < elements.length; i++) {
+          const sub = elements.slice(0, i + 1).join("/") + "/";
+          foldersList.add(sub);
+        }
+      }
+      for (const elem of foldersList) {
+        if (!(elem in entryTable)) {
+          const tempfolder = new ZipEntry(opts);
+          tempfolder.entryName = elem;
+          tempfolder.attr = 16;
+          tempfolder.temporary = true;
+          entryList.push(tempfolder);
+          entryTable[tempfolder.entryName] = tempfolder;
+          temporary.add(tempfolder);
+        }
+      }
+    }
+    function readEntries() {
+      loadedEntries = true;
+      entryTable = Object.create(null);
+      if (mainHeader.diskEntries > (inBuffer.length - mainHeader.offset) / Utils.Constants.CENHDR) {
+        throw Utils.Errors.DISK_ENTRY_TOO_LARGE();
+      }
+      entryList = new Array(mainHeader.diskEntries);
+      var index = mainHeader.offset;
+      for (var i = 0;i < entryList.length; i++) {
+        var tmp = index, entry = new ZipEntry(opts, inBuffer);
+        entry.header = inBuffer.slice(tmp, tmp += Utils.Constants.CENHDR);
+        entry.entryName = inBuffer.slice(tmp, tmp += entry.header.fileNameLength);
+        if (entry.header.extraLength) {
+          entry.extra = inBuffer.slice(tmp, tmp += entry.header.extraLength);
+        }
+        if (entry.header.commentLength)
+          entry.comment = inBuffer.slice(tmp, tmp + entry.header.commentLength);
+        index += entry.header.centralHeaderSize;
+        entryList[i] = entry;
+        entryTable[entry.entryName] = entry;
+      }
+      temporary.clear();
+      makeTemporaryFolders();
+    }
+    function readMainHeader(readNow) {
+      var i = inBuffer.length - Utils.Constants.ENDHDR, max = Math.max(0, i - 65535), n = max, endStart = inBuffer.length, endOffset = -1, commentEnd = 0;
+      const trailingSpace = typeof opts.trailingSpace === "boolean" ? opts.trailingSpace : false;
+      if (trailingSpace)
+        max = 0;
+      for (i;i >= n; i--) {
+        if (inBuffer[i] !== 80)
+          continue;
+        if (inBuffer.readUInt32LE(i) === Utils.Constants.ENDSIG) {
+          endOffset = i;
+          commentEnd = i;
+          endStart = i + Utils.Constants.ENDHDR;
+          n = i - Utils.Constants.END64HDR;
+          continue;
+        }
+        if (inBuffer.readUInt32LE(i) === Utils.Constants.END64SIG) {
+          n = max;
+          continue;
+        }
+        if (inBuffer.readUInt32LE(i) === Utils.Constants.ZIP64SIG) {
+          endOffset = i;
+          endStart = i + Utils.readBigUInt64LE(inBuffer, i + Utils.Constants.ZIP64SIZE) + Utils.Constants.ZIP64LEAD;
+          break;
+        }
+      }
+      if (endOffset == -1)
+        throw Utils.Errors.INVALID_FORMAT();
+      mainHeader.loadFromBinary(inBuffer.slice(endOffset, endStart));
+      if (mainHeader.commentLength) {
+        _comment = inBuffer.slice(commentEnd + Utils.Constants.ENDHDR);
+      }
+      if (readNow)
+        readEntries();
+    }
+    function sortEntries() {
+      if (entryList.length > 1 && !noSort) {
+        entryList = entryList.map((entry) => ({ entry, key: entry.entryName.toLowerCase() })).sort((a, b) => a.key.localeCompare(b.key)).map((pair) => pair.entry);
+      }
+    }
+    return {
+      get entries() {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        return entryList.filter((e) => !temporary.has(e));
+      },
+      get comment() {
+        return decoder.decode(_comment);
+      },
+      set comment(val) {
+        _comment = Utils.toBuffer(val, decoder.encode);
+        mainHeader.commentLength = _comment.length;
+      },
+      getEntryCount: function() {
+        if (!loadedEntries) {
+          return mainHeader.diskEntries;
+        }
+        return entryList.length;
+      },
+      forEach: function(callback) {
+        this.entries.forEach(callback);
+      },
+      getEntry: function(entryName) {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        return entryTable[entryName] || null;
+      },
+      setEntry: function(entry) {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        entryList.push(entry);
+        entryTable[entry.entryName] = entry;
+        mainHeader.totalEntries = entryList.length;
+      },
+      deleteFile: function(entryName, withsubfolders = true) {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        const entry = entryTable[entryName];
+        const list = this.getEntryChildren(entry, withsubfolders).map((child) => child.entryName);
+        list.forEach(this.deleteEntry);
+      },
+      deleteEntry: function(entryName) {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        const entry = entryTable[entryName];
+        const index = entryList.indexOf(entry);
+        if (index >= 0) {
+          entryList.splice(index, 1);
+          delete entryTable[entryName];
+          mainHeader.totalEntries = entryList.length;
+        }
+      },
+      getEntryChildren: function(entry, subfolders = true) {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        if (typeof entry === "object") {
+          if (entry.isDirectory && subfolders) {
+            const list = [];
+            const name = entry.entryName;
+            for (const zipEntry of entryList) {
+              if (zipEntry.entryName.startsWith(name)) {
+                list.push(zipEntry);
+              }
+            }
+            return list;
+          } else {
+            return [entry];
+          }
+        }
+        return [];
+      },
+      getChildCount: function(entry) {
+        if (entry && entry.isDirectory) {
+          const list = this.getEntryChildren(entry);
+          return list.includes(entry) ? list.length - 1 : list.length;
+        }
+        return 0;
+      },
+      compressToBuffer: function() {
+        if (!loadedEntries) {
+          readEntries();
+        }
+        sortEntries();
+        const dataBlock = [];
+        const headerBlocks = [];
+        let totalSize = 0;
+        let dindex = 0;
+        mainHeader.size = 0;
+        mainHeader.offset = 0;
+        let totalEntries = 0;
+        for (const entry of this.entries) {
+          const compressedData = entry.getCompressedData();
+          entry.header.offset = dindex;
+          const localHeader = entry.packLocalHeader();
+          const dataLength = localHeader.length + compressedData.length;
+          dindex += dataLength;
+          dataBlock.push(localHeader);
+          dataBlock.push(compressedData);
+          const centralHeader = entry.packCentralHeader();
+          headerBlocks.push(centralHeader);
+          mainHeader.size += centralHeader.length;
+          totalSize += dataLength + centralHeader.length;
+          totalEntries++;
+        }
+        totalSize += mainHeader.mainHeaderSize;
+        mainHeader.offset = dindex;
+        mainHeader.totalEntries = totalEntries;
+        dindex = 0;
+        const outBuffer = Buffer.alloc(totalSize);
+        for (const content of dataBlock) {
+          content.copy(outBuffer, dindex);
+          dindex += content.length;
+        }
+        for (const content of headerBlocks) {
+          content.copy(outBuffer, dindex);
+          dindex += content.length;
+        }
+        const mh = mainHeader.toBinary();
+        if (_comment) {
+          _comment.copy(mh, mh.length - _comment.length);
+        }
+        mh.copy(outBuffer, dindex);
+        inBuffer = outBuffer;
+        loadedEntries = false;
+        return outBuffer;
+      },
+      toAsyncBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
+        try {
+          if (!loadedEntries) {
+            readEntries();
+          }
+          sortEntries();
+          const dataBlock = [];
+          const centralHeaders = [];
+          let totalSize = 0;
+          let dindex = 0;
+          let totalEntries = 0;
+          mainHeader.size = 0;
+          mainHeader.offset = 0;
+          const compress2Buffer = function(entryLists) {
+            if (entryLists.length > 0) {
+              const entry = entryLists.shift();
+              const name = entry.entryName + entry.extra.toString();
+              if (onItemStart)
+                onItemStart(name);
+              entry.getCompressedDataAsync(function(compressedData) {
+                if (onItemEnd)
+                  onItemEnd(name);
+                entry.header.offset = dindex;
+                const localHeader = entry.packLocalHeader();
+                const dataLength = localHeader.length + compressedData.length;
+                dindex += dataLength;
+                dataBlock.push(localHeader);
+                dataBlock.push(compressedData);
+                const centalHeader = entry.packCentralHeader();
+                centralHeaders.push(centalHeader);
+                mainHeader.size += centalHeader.length;
+                totalSize += dataLength + centalHeader.length;
+                totalEntries++;
+                compress2Buffer(entryLists);
+              });
+            } else {
+              totalSize += mainHeader.mainHeaderSize;
+              mainHeader.offset = dindex;
+              mainHeader.totalEntries = totalEntries;
+              dindex = 0;
+              const outBuffer = Buffer.alloc(totalSize);
+              dataBlock.forEach(function(content) {
+                content.copy(outBuffer, dindex);
+                dindex += content.length;
+              });
+              centralHeaders.forEach(function(content) {
+                content.copy(outBuffer, dindex);
+                dindex += content.length;
+              });
+              const mh = mainHeader.toBinary();
+              if (_comment) {
+                _comment.copy(mh, mh.length - _comment.length);
+              }
+              mh.copy(outBuffer, dindex);
+              inBuffer = outBuffer;
+              loadedEntries = false;
+              onSuccess(outBuffer);
+            }
+          };
+          compress2Buffer(Array.from(this.entries));
+        } catch (e) {
+          onFail(e);
+        }
+      }
+    };
+  };
+});
+
+// ../../node_modules/adm-zip/adm-zip.js
+var require_adm_zip = __commonJS((exports, module) => {
+  var Utils = require_util();
+  var pth = __require("path");
+  var ZipEntry = require_zipEntry();
+  var ZipFile = require_zipFile();
+  var get_Bool = (...val) => Utils.findLast(val, (c) => typeof c === "boolean");
+  var get_Str = (...val) => Utils.findLast(val, (c) => typeof c === "string");
+  var get_Fun = (...val) => Utils.findLast(val, (c) => typeof c === "function");
+  var defaultOptions = {
+    noSort: false,
+    readEntries: false,
+    method: Utils.Constants.NONE,
+    fs: null
+  };
+  module.exports = function(input, options) {
+    let inBuffer = null;
+    const opts = Object.assign(Object.create(null), defaultOptions);
+    if (input && typeof input === "object") {
+      if (!(input instanceof Uint8Array)) {
+        Object.assign(opts, input);
+        input = opts.input ? opts.input : undefined;
+        if (opts.input)
+          delete opts.input;
+      }
+      if (Buffer.isBuffer(input)) {
+        inBuffer = input;
+        opts.method = Utils.Constants.BUFFER;
+        input = undefined;
+      }
+    }
+    Object.assign(opts, options);
+    const filetools = new Utils(opts);
+    const applyDirAttributes = (dirEntries) => {
+      dirEntries.filter((d) => d.attr).sort((a, b) => b.path.length - a.path.length).forEach((d) => filetools.fs.chmodSync(d.path, d.attr));
+    };
+    if (typeof opts.decoder !== "object" || typeof opts.decoder.encode !== "function" || typeof opts.decoder.decode !== "function") {
+      opts.decoder = Utils.decoder;
+    }
+    if (input && typeof input === "string") {
+      if (filetools.fs.existsSync(input)) {
+        opts.method = Utils.Constants.FILE;
+        opts.filename = input;
+        inBuffer = filetools.fs.readFileSync(input);
+      } else {
+        throw Utils.Errors.INVALID_FILENAME();
+      }
+    }
+    const _zip = new ZipFile(inBuffer, opts);
+    const { canonical, sanitize, zipnamefix } = Utils;
+    function getEntry(entry) {
+      if (entry && _zip) {
+        var item;
+        if (typeof entry === "string")
+          item = _zip.getEntry(pth.posix.normalize(entry));
+        if (typeof entry === "object" && typeof entry.entryName !== "undefined" && typeof entry.header !== "undefined")
+          item = _zip.getEntry(entry.entryName);
+        if (item) {
+          return item;
+        }
+      }
+      return null;
+    }
+    function fixPath(zipPath) {
+      const { join, normalize, sep } = pth.posix;
+      return join(pth.isAbsolute(zipPath) ? "/" : ".", normalize(sep + zipPath.split("\\").join(sep) + sep));
+    }
+    function filenameFilter(filterfn) {
+      if (filterfn instanceof RegExp) {
+        return function(rx) {
+          return function(filename) {
+            return rx.test(filename);
+          };
+        }(filterfn);
+      } else if (typeof filterfn !== "function") {
+        return () => true;
+      }
+      return filterfn;
+    }
+    const relativePath = (local, entry) => {
+      let lastChar = entry.slice(-1);
+      lastChar = lastChar === filetools.sep ? filetools.sep : "";
+      return pth.relative(local, entry) + lastChar;
+    };
+    return {
+      readFile: function(entry, pass) {
+        var item = getEntry(entry);
+        return item && item.getData(pass) || null;
+      },
+      childCount: function(entry) {
+        const item = getEntry(entry);
+        if (item) {
+          return _zip.getChildCount(item);
+        }
+      },
+      readFileAsync: function(entry, callback) {
+        var item = getEntry(entry);
+        if (item) {
+          item.getDataAsync(callback);
+        } else {
+          callback(null, "getEntry failed for:" + entry);
+        }
+      },
+      readAsText: function(entry, encoding) {
+        var item = getEntry(entry);
+        if (item) {
+          var data = item.getData();
+          if (data && data.length) {
+            return data.toString(encoding || "utf8");
+          }
+        }
+        return "";
+      },
+      readAsTextAsync: function(entry, callback, encoding) {
+        var item = getEntry(entry);
+        if (item) {
+          item.getDataAsync(function(data, err) {
+            if (err) {
+              callback(data, err);
+              return;
+            }
+            if (data && data.length) {
+              callback(data.toString(encoding || "utf8"));
+            } else {
+              callback("");
+            }
+          });
+        } else {
+          callback("");
+        }
+      },
+      deleteFile: function(entry, withsubfolders = true) {
+        var item = getEntry(entry);
+        if (item) {
+          _zip.deleteFile(item.entryName, withsubfolders);
+        }
+      },
+      deleteEntry: function(entry) {
+        var item = getEntry(entry);
+        if (item) {
+          _zip.deleteEntry(item.entryName);
+        }
+      },
+      addZipComment: function(comment) {
+        _zip.comment = comment;
+      },
+      getZipComment: function() {
+        return _zip.comment || "";
+      },
+      addZipEntryComment: function(entry, comment) {
+        var item = getEntry(entry);
+        if (item) {
+          item.comment = comment;
+        }
+      },
+      getZipEntryComment: function(entry) {
+        var item = getEntry(entry);
+        if (item) {
+          return item.comment || "";
+        }
+        return "";
+      },
+      updateFile: function(entry, content) {
+        var item = getEntry(entry);
+        if (item) {
+          item.setData(content);
+        }
+      },
+      addLocalFile: function(localPath, zipPath, zipName, comment) {
+        if (filetools.fs.existsSync(localPath)) {
+          zipPath = zipPath ? fixPath(zipPath) : "";
+          const p = pth.win32.basename(pth.win32.normalize(localPath));
+          zipPath += zipName ? zipName : p;
+          const _attr = filetools.fs.statSync(localPath);
+          const data = _attr.isFile() ? filetools.fs.readFileSync(localPath) : Buffer.alloc(0);
+          if (_attr.isDirectory())
+            zipPath += filetools.sep;
+          this.addFile(zipPath, data, comment, _attr);
+        } else {
+          throw Utils.Errors.FILE_NOT_FOUND(localPath);
+        }
+      },
+      addLocalFileAsync: function(options2, callback) {
+        options2 = typeof options2 === "object" ? options2 : { localPath: options2 };
+        const localPath = pth.resolve(options2.localPath);
+        const { comment } = options2;
+        let { zipPath, zipName } = options2;
+        const self = this;
+        filetools.fs.stat(localPath, function(err, stats) {
+          if (err)
+            return callback(err, false);
+          zipPath = zipPath ? fixPath(zipPath) : "";
+          const p = pth.win32.basename(pth.win32.normalize(localPath));
+          zipPath += zipName ? zipName : p;
+          if (stats.isFile()) {
+            filetools.fs.readFile(localPath, function(err2, data) {
+              if (err2)
+                return callback(err2, false);
+              self.addFile(zipPath, data, comment, stats);
+              return setImmediate(callback, undefined, true);
+            });
+          } else if (stats.isDirectory()) {
+            zipPath += filetools.sep;
+            self.addFile(zipPath, Buffer.alloc(0), comment, stats);
+            return setImmediate(callback, undefined, true);
+          }
+        });
+      },
+      addLocalFolder: function(localPath, zipPath, filter) {
+        filter = filenameFilter(filter);
+        zipPath = zipPath ? fixPath(zipPath) : "";
+        localPath = pth.normalize(localPath);
+        if (filetools.fs.existsSync(localPath)) {
+          const items = filetools.findFiles(localPath);
+          const self = this;
+          if (items.length) {
+            for (const filepath of items) {
+              const p = pth.join(zipPath, relativePath(localPath, filepath));
+              if (filter(p)) {
+                self.addLocalFile(filepath, pth.dirname(p));
+              }
+            }
+          }
+        } else {
+          throw Utils.Errors.FILE_NOT_FOUND(localPath);
+        }
+      },
+      addLocalFolderAsync: function(localPath, callback, zipPath, filter) {
+        filter = filenameFilter(filter);
+        zipPath = zipPath ? fixPath(zipPath) : "";
+        localPath = pth.normalize(localPath);
+        var self = this;
+        filetools.fs.open(localPath, "r", function(err) {
+          if (err && err.code === "ENOENT") {
+            callback(undefined, Utils.Errors.FILE_NOT_FOUND(localPath));
+          } else if (err) {
+            callback(undefined, err);
+          } else {
+            var items = filetools.findFiles(localPath);
+            var i = -1;
+            var next = function() {
+              i += 1;
+              if (i < items.length) {
+                var filepath = items[i];
+                var p = relativePath(localPath, filepath).split("\\").join("/");
+                p = p.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^\x20-\x7E]/g, "");
+                if (filter(p)) {
+                  filetools.fs.stat(filepath, function(er0, stats) {
+                    if (er0)
+                      callback(undefined, er0);
+                    if (stats.isFile()) {
+                      filetools.fs.readFile(filepath, function(er1, data) {
+                        if (er1) {
+                          callback(undefined, er1);
+                        } else {
+                          self.addFile(zipPath + p, data, "", stats);
+                          next();
+                        }
+                      });
+                    } else {
+                      self.addFile(zipPath + p + "/", Buffer.alloc(0), "", stats);
+                      next();
+                    }
+                  });
+                } else {
+                  process.nextTick(() => {
+                    next();
+                  });
+                }
+              } else {
+                callback(true, undefined);
+              }
+            };
+            next();
+          }
+        });
+      },
+      addLocalFolderAsync2: function(options2, callback) {
+        const self = this;
+        options2 = typeof options2 === "object" ? options2 : { localPath: options2 };
+        const localPath = pth.resolve(fixPath(options2.localPath));
+        let { zipPath, filter, namefix } = options2;
+        if (filter instanceof RegExp) {
+          filter = function(rx) {
+            return function(filename) {
+              return rx.test(filename);
+            };
+          }(filter);
+        } else if (typeof filter !== "function") {
+          filter = function() {
+            return true;
+          };
+        }
+        zipPath = zipPath ? fixPath(zipPath) : "";
+        if (namefix === "latin1") {
+          namefix = (str) => str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^\x20-\x7E]/g, "");
+        }
+        if (typeof namefix !== "function")
+          namefix = (str) => str;
+        const relPathFix = (entry) => pth.join(zipPath, namefix(relativePath(localPath, entry)));
+        const fileNameFix = (entry) => pth.win32.basename(pth.win32.normalize(namefix(entry)));
+        filetools.fs.open(localPath, "r", function(err) {
+          if (err && err.code === "ENOENT") {
+            callback(undefined, Utils.Errors.FILE_NOT_FOUND(localPath));
+          } else if (err) {
+            callback(undefined, err);
+          } else {
+            filetools.findFilesAsync(localPath, function(err2, fileEntries) {
+              if (err2)
+                return callback(err2);
+              fileEntries = fileEntries.filter((dir) => filter(relPathFix(dir)));
+              if (!fileEntries.length)
+                callback(undefined, false);
+              setImmediate(fileEntries.reverse().reduce(function(next, entry) {
+                return function(err3, done) {
+                  if (err3 || done === false)
+                    return setImmediate(next, err3, false);
+                  self.addLocalFileAsync({
+                    localPath: entry,
+                    zipPath: pth.dirname(relPathFix(entry)),
+                    zipName: fileNameFix(entry)
+                  }, next);
+                };
+              }, callback));
+            });
+          }
+        });
+      },
+      addLocalFolderPromise: function(localPath, props) {
+        return new Promise((resolve, reject) => {
+          this.addLocalFolderAsync2(Object.assign({ localPath }, props), (err, done) => {
+            if (err)
+              reject(err);
+            if (done)
+              resolve(this);
+          });
+        });
+      },
+      addFile: function(entryName, content, comment, attr) {
+        entryName = zipnamefix(entryName);
+        let entry = getEntry(entryName);
+        const update = entry != null;
+        if (!update) {
+          entry = new ZipEntry(opts);
+          entry.entryName = entryName;
+        }
+        entry.comment = comment || "";
+        const isStat = typeof attr === "object" && attr instanceof filetools.fs.Stats;
+        if (isStat) {
+          entry.header.time = attr.mtime;
+        }
+        var fileattr = entry.isDirectory ? 16 : 0;
+        let unix = entry.isDirectory ? 16384 : 32768;
+        if (isStat) {
+          unix |= 4095 & attr.mode;
+        } else if (typeof attr === "number") {
+          unix |= 4095 & attr;
+        } else {
+          unix |= entry.isDirectory ? 493 : 420;
+        }
+        fileattr = (fileattr | unix << 16) >>> 0;
+        entry.attr = fileattr;
+        entry.setData(content);
+        if (!update)
+          _zip.setEntry(entry);
+        return entry;
+      },
+      getEntries: function(password) {
+        _zip.password = password;
+        return _zip ? _zip.entries : [];
+      },
+      getEntry: function(name) {
+        return getEntry(name);
+      },
+      getEntryCount: function() {
+        return _zip.getEntryCount();
+      },
+      forEach: function(callback) {
+        return _zip.forEach(callback);
+      },
+      extractEntryTo: function(entry, targetPath, maintainEntryPath, overwrite, keepOriginalPermission, outFileName) {
+        overwrite = get_Bool(false, overwrite);
+        keepOriginalPermission = get_Bool(false, keepOriginalPermission);
+        maintainEntryPath = get_Bool(true, maintainEntryPath);
+        outFileName = get_Str(keepOriginalPermission, outFileName);
+        var item = getEntry(entry);
+        if (!item) {
+          throw Utils.Errors.NO_ENTRY();
+        }
+        var entryName = canonical(item.entryName);
+        var target = sanitize(targetPath, outFileName && !item.isDirectory ? canonical(outFileName) : maintainEntryPath ? entryName : pth.basename(entryName));
+        if (item.isDirectory) {
+          var children = _zip.getEntryChildren(item);
+          children.forEach(function(child) {
+            if (child.isDirectory)
+              return;
+            var content2 = child.getData();
+            if (!content2) {
+              throw Utils.Errors.CANT_EXTRACT_FILE();
+            }
+            var name = canonical(maintainEntryPath ? child.entryName : child.entryName.substring(item.entryName.length));
+            var childName = sanitize(targetPath, name);
+            const fileAttr2 = keepOriginalPermission ? child.header.fileAttr : undefined;
+            filetools.writeFileTo(childName, content2, overwrite, fileAttr2);
+          });
+          return true;
+        }
+        var content = item.getData(_zip.password);
+        if (!content)
+          throw Utils.Errors.CANT_EXTRACT_FILE();
+        if (filetools.fs.existsSync(target) && !overwrite) {
+          throw Utils.Errors.CANT_OVERRIDE();
+        }
+        const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
+        filetools.writeFileTo(target, content, overwrite, fileAttr);
+        return true;
+      },
+      test: function(pass) {
+        if (!_zip) {
+          return false;
+        }
+        for (var entry of _zip.entries) {
+          try {
+            if (entry.isDirectory) {
+              continue;
+            }
+            var content = entry.getData(pass);
+            if (!content) {
+              return false;
+            }
+          } catch (err) {
+            return false;
+          }
+        }
+        return true;
+      },
+      extractAllTo: function(targetPath, overwrite, keepOriginalPermission, pass) {
+        keepOriginalPermission = get_Bool(false, keepOriginalPermission);
+        pass = get_Str(keepOriginalPermission, pass);
+        overwrite = get_Bool(false, overwrite);
+        if (!_zip)
+          throw Utils.Errors.NO_ZIP();
+        const dirEntries = [];
+        _zip.entries.forEach(function(entry) {
+          var entryName = sanitize(targetPath, canonical(entry.entryName));
+          if (entry.isDirectory) {
+            filetools.makeDir(entryName);
+            if (keepOriginalPermission)
+              dirEntries.push({ path: entryName, attr: entry.header.fileAttr });
+            return;
+          }
+          var content = entry.getData(pass);
+          if (!content) {
+            throw Utils.Errors.CANT_EXTRACT_FILE();
+          }
+          const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
+          filetools.writeFileTo(entryName, content, overwrite, fileAttr);
+          try {
+            filetools.fs.utimesSync(entryName, entry.header.time, entry.header.time);
+          } catch (err) {}
+        });
+        applyDirAttributes(dirEntries);
+      },
+      extractAllToAsync: function(targetPath, overwrite, keepOriginalPermission, callback) {
+        callback = get_Fun(overwrite, keepOriginalPermission, callback);
+        keepOriginalPermission = get_Bool(false, keepOriginalPermission);
+        overwrite = get_Bool(false, overwrite);
+        if (!callback) {
+          return new Promise((resolve, reject) => {
+            this.extractAllToAsync(targetPath, overwrite, keepOriginalPermission, function(err) {
+              if (err) {
+                reject(err);
+              } else {
+                resolve(this);
+              }
+            });
+          });
+        }
+        if (!_zip) {
+          callback(Utils.Errors.NO_ZIP());
+          return;
+        }
+        targetPath = pth.resolve(targetPath);
+        const getPath = (entry) => sanitize(targetPath, pth.normalize(canonical(entry.entryName)));
+        const getError = (msg, file) => new Error(msg + ': "' + file + '"');
+        const dirEntries = [];
+        const fileEntries = [];
+        _zip.entries.forEach((e) => {
+          if (e.isDirectory) {
+            dirEntries.push(e);
+          } else {
+            fileEntries.push(e);
+          }
+        });
+        const deferredDirAttr = [];
+        for (const entry of dirEntries) {
+          const dirPath = getPath(entry);
+          const dirAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
+          try {
+            filetools.makeDir(dirPath);
+          } catch (er) {
+            callback(getError("Unable to create folder", dirPath));
+            continue;
+          }
+          if (dirAttr)
+            deferredDirAttr.push({ path: dirPath, attr: dirAttr });
+          try {
+            filetools.fs.utimesSync(dirPath, entry.header.time, entry.header.time);
+          } catch (er) {}
+        }
+        const done = (err) => {
+          if (!err) {
+            try {
+              applyDirAttributes(deferredDirAttr);
+            } catch (er) {
+              return callback(getError("Unable to set folder permissions", er.path || ""));
+            }
+          }
+          callback(err);
+        };
+        fileEntries.reverse().reduce(function(next, entry) {
+          return function(err) {
+            if (err) {
+              next(err);
+            } else {
+              const entryName = pth.normalize(canonical(entry.entryName));
+              const filePath = sanitize(targetPath, entryName);
+              entry.getDataAsync(function(content, err_1) {
+                if (err_1) {
+                  next(err_1);
+                } else if (!content) {
+                  next(Utils.Errors.CANT_EXTRACT_FILE());
+                } else {
+                  const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
+                  filetools.writeFileToAsync(filePath, content, overwrite, fileAttr, function(succ) {
+                    if (!succ) {
+                      return next(getError("Unable to write file", filePath));
+                    }
+                    filetools.fs.utimes(filePath, entry.header.time, entry.header.time, function() {
+                      next();
+                    });
+                  });
+                }
+              });
+            }
+          };
+        }, done)();
+      },
+      writeZip: function(targetFileName, callback) {
+        if (arguments.length === 1) {
+          if (typeof targetFileName === "function") {
+            callback = targetFileName;
+            targetFileName = "";
+          }
+        }
+        if (!targetFileName && opts.filename) {
+          targetFileName = opts.filename;
+        }
+        if (!targetFileName)
+          return;
+        var zipData = _zip.compressToBuffer();
+        if (zipData) {
+          var ok = filetools.writeFileTo(targetFileName, zipData, true);
+          if (typeof callback === "function")
+            callback(!ok ? new Error("failed") : null, "");
+        }
+      },
+      writeZipPromise: function(targetFileName, props) {
+        const { overwrite, perm } = Object.assign({ overwrite: true }, props);
+        return new Promise((resolve, reject) => {
+          if (!targetFileName && opts.filename)
+            targetFileName = opts.filename;
+          if (!targetFileName)
+            reject("ADM-ZIP: ZIP File Name Missing");
+          this.toBufferPromise().then((zipData) => {
+            const ret = (done) => done ? resolve(done) : reject("ADM-ZIP: Wasn't able to write zip file");
+            filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
+          }, reject);
+        });
+      },
+      toBufferPromise: function() {
+        return new Promise((resolve, reject) => {
+          _zip.toAsyncBuffer(resolve, reject);
+        });
+      },
+      toBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
+        if (typeof onSuccess === "function") {
+          _zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd);
+          return null;
+        }
+        return _zip.compressToBuffer();
+      }
+    };
+  };
+});
+
+// ../solution-sdk/generated/src/runtime.ts
+var BASE_PATH = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_".replace(/\/+$/, "");
+
+class Configuration {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig = new Configuration;
+
+class BaseAPI {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+
+class RequiredError extends Error {
+  field;
+  name = "RequiredError";
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+  }
+}
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+class JSONApiResponse {
+  raw;
+  transformer;
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+}
+
+class VoidApiResponse {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return;
+  }
+}
+class TextApiResponse {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.text();
+  }
+}
+
+// ../solution-sdk/generated/src/models/ResponseDictionaryDto.ts
+function ResponseDictionaryDtoFromJSON(json) {
+  return ResponseDictionaryDtoFromJSONTyped(json, false);
+}
+function ResponseDictionaryDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    keys: json["keys"] == null ? undefined : json["keys"],
+    values: json["values"] == null ? undefined : json["values"]
+  };
+}
+
+// ../solution-sdk/generated/src/models/BlobFileAccessDto.ts
+function BlobFileAccessDtoFromJSON(json) {
+  return BlobFileAccessDtoFromJSONTyped(json, false);
+}
+function BlobFileAccessDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    uri: json["uri"],
+    verb: json["verb"],
+    headers: json["headers"] == null ? undefined : ResponseDictionaryDtoFromJSON(json["headers"])
+  };
+}
+// ../solution-sdk/generated/src/models/CreateConfigurationCommand.ts
+function CreateConfigurationCommandToJSON(json) {
+  return CreateConfigurationCommandToJSONTyped(json, false);
+}
+function CreateConfigurationCommandToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    packageVersionKey: value["packageVersionKey"],
+    name: value["name"]
+  };
+}
+// ../solution-sdk/generated/src/models/DeploymentActivationStatus.ts
+function DeploymentActivationStatusFromJSON(json) {
+  return DeploymentActivationStatusFromJSONTyped(json, false);
+}
+function DeploymentActivationStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+// ../solution-sdk/generated/src/models/OverwriteType.ts
+function OverwriteTypeToJSON(value) {
+  return value;
+}
+
+// ../solution-sdk/generated/src/models/Overwrite.ts
+function OverwriteToJSON(json) {
+  return OverwriteToJSONTyped(json, false);
+}
+function OverwriteToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    resourceKey: value["resourceKey"],
+    resourceName: value["resourceName"],
+    folderKey: value["folderKey"],
+    folderFullyQualifiedName: value["folderFullyQualifiedName"],
+    folderPath: value["folderPath"],
+    type: OverwriteTypeToJSON(value["type"])
+  };
+}
+
+// ../solution-sdk/generated/src/models/ResourceOverwrite.ts
+function ResourceOverwriteToJSON(json) {
+  return ResourceOverwriteToJSONTyped(json, false);
+}
+function ResourceOverwriteToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    solutionResourceKey: value["solutionResourceKey"],
+    reprovisioningIndex: value["reprovisioningIndex"],
+    overwrite: OverwriteToJSON(value["overwrite"])
+  };
+}
+
+// ../solution-sdk/generated/src/models/RuntimeSetup.ts
+function RuntimeSetupFromJSON(json) {
+  return RuntimeSetupFromJSONTyped(json, false);
+}
+function RuntimeSetupFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    requireServerlessTemplate: json["requireServerlessTemplate"]
+  };
+}
+function RuntimeSetupToJSON(json) {
+  return RuntimeSetupToJSONTyped(json, false);
+}
+function RuntimeSetupToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    requireServerlessTemplate: value["requireServerlessTemplate"]
+  };
+}
+
+// ../solution-sdk/generated/src/models/DeploymentAutoRequest.ts
+function DeploymentAutoRequestToJSON(json) {
+  return DeploymentAutoRequestToJSONTyped(json, false);
+}
+function DeploymentAutoRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    packageVersionKey: value["packageVersionKey"],
+    folderFQN: value["folderFQN"],
+    overwrites: value["overwrites"].map(ResourceOverwriteToJSON),
+    runtimeSetup: RuntimeSetupToJSON(value["runtimeSetup"])
+  };
+}
+// ../solution-sdk/generated/src/models/DeploymentDto.ts
+function DeploymentDtoFromJSON(json) {
+  return DeploymentDtoFromJSONTyped(json, false);
+}
+function DeploymentDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    packageName: json["packageName"],
+    deploymentName: json["deploymentName"]
+  };
+}
+// ../solution-sdk/generated/src/models/WorkflowAction.ts
+function WorkflowActionFromJSON(json) {
+  return WorkflowActionFromJSONTyped(json, false);
+}
+function WorkflowActionFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../solution-sdk/generated/src/models/DeploymentOperation.ts
+function DeploymentOperationFromJSON(json) {
+  return DeploymentOperationFromJSONTyped(json, false);
+}
+function DeploymentOperationFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../solution-sdk/generated/src/models/PackageVersionOrigin.ts
+function PackageVersionOriginFromJSON(json) {
+  return PackageVersionOriginFromJSONTyped(json, false);
+}
+function PackageVersionOriginFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../solution-sdk/generated/src/models/DeploymentOperationStatus.ts
+function DeploymentOperationStatusFromJSON(json) {
+  return DeploymentOperationStatusFromJSONTyped(json, false);
+}
+function DeploymentOperationStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../solution-sdk/generated/src/models/DeploymentUpgradeType.ts
+function DeploymentUpgradeTypeFromJSON(json) {
+  return DeploymentUpgradeTypeFromJSONTyped(json, false);
+}
+function DeploymentUpgradeTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../solution-sdk/generated/src/models/DeploymentStatus.ts
+function DeploymentStatusFromJSON(json) {
+  return DeploymentStatusFromJSONTyped(json, false);
+}
+function DeploymentStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+
+// ../solution-sdk/generated/src/models/DeploymentItemDto.ts
+function DeploymentItemDtoFromJSON(json) {
+  return DeploymentItemDtoFromJSONTyped(json, false);
+}
+function DeploymentItemDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["key"],
+    installDeploymentKey: json["installDeploymentKey"],
+    name: json["name"],
+    configurationKey: json["configurationKey"],
+    packageVersionKey: json["packageVersionKey"],
+    packageKey: json["packageKey"],
+    packageName: json["packageName"],
+    packageVersion: json["packageVersion"],
+    currentPackageVersion: json["currentPackageVersion"] == null ? undefined : json["currentPackageVersion"],
+    targetPackageVersion: json["targetPackageVersion"] == null ? undefined : json["targetPackageVersion"],
+    folderPath: json["folderPath"] == null ? undefined : json["folderPath"],
+    installedRootFolderKey: json["installedRootFolderKey"] == null ? undefined : json["installedRootFolderKey"],
+    installedRootFolderName: json["installedRootFolderName"] == null ? undefined : json["installedRootFolderName"],
+    packageVersionOrigin: PackageVersionOriginFromJSON(json["packageVersionOrigin"]),
+    deploymentCreationTime: new Date(json["deploymentCreationTime"]),
+    status: DeploymentStatusFromJSON(json["status"]),
+    startTime: json["startTime"] == null ? undefined : new Date(json["startTime"]),
+    endTime: json["endTime"] == null ? undefined : new Date(json["endTime"]),
+    upgradeType: json["upgradeType"] == null ? undefined : DeploymentUpgradeTypeFromJSON(json["upgradeType"]),
+    operation: DeploymentOperationFromJSON(json["operation"]),
+    operationStatus: DeploymentOperationStatusFromJSON(json["operationStatus"]),
+    activationStatus: DeploymentActivationStatusFromJSON(json["activationStatus"]),
+    instanceId: json["instanceId"] == null ? undefined : json["instanceId"],
+    newPackageVersionAvailable: json["newPackageVersionAvailable"] == null ? undefined : json["newPackageVersionAvailable"],
+    packageVersionDescription: json["packageVersionDescription"] == null ? undefined : json["packageVersionDescription"],
+    packageVersionReleaseNotes: json["packageVersionReleaseNotes"] == null ? undefined : json["packageVersionReleaseNotes"],
+    authorName: json["authorName"],
+    previousDeploymentKey: json["previousDeploymentKey"] == null ? undefined : json["previousDeploymentKey"],
+    runtimeSetup: json["runtimeSetup"] == null ? undefined : RuntimeSetupFromJSON(json["runtimeSetup"]),
+    actions: json["actions"].map(WorkflowActionFromJSON)
+  };
+}
+// ../solution-sdk/generated/src/models/DeploymentRequest.ts
+function DeploymentRequestToJSON(json) {
+  return DeploymentRequestToJSONTyped(json, false);
+}
+function DeploymentRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    configurationKey: value["configurationKey"],
+    deploymentName: value["deploymentName"],
+    installationFolderKey: value["installationFolderKey"],
+    pathFullyQualifiedName: value["pathFullyQualifiedName"],
+    solutionRootFolderName: value["solutionRootFolderName"],
+    forceActivate: value["forceActivate"],
+    runtimeSetup: RuntimeSetupToJSON(value["runtimeSetup"])
+  };
+}
+// ../solution-sdk/generated/src/models/DeploymentUpgradeRequest.ts
+function DeploymentUpgradeRequestToJSON(json) {
+  return DeploymentUpgradeRequestToJSONTyped(json, false);
+}
+function DeploymentUpgradeRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    deploymentName: value["deploymentName"],
+    packageVersionKey: value["packageVersionKey"]
+  };
+}
+// ../solution-sdk/generated/src/models/ExtendedPackageVersionState.ts
+function ExtendedPackageVersionStateFromJSON(json) {
+  return ExtendedPackageVersionStateFromJSONTyped(json, false);
+}
+function ExtendedPackageVersionStateFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+// ../solution-sdk/generated/src/models/FolderInfo.ts
+function FolderInfoFromJSON(json) {
+  return FolderInfoFromJSONTyped(json, false);
+}
+function FolderInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    fullyQualifiedName: json["fullyQualifiedName"],
+    path: json["path"] == null ? undefined : json["path"],
+    folderKey: json["folderKey"] == null ? undefined : json["folderKey"]
+  };
+}
+// ../solution-sdk/generated/src/models/LocationDto.ts
+function LocationDtoFromJSON(json) {
+  return LocationDtoFromJSONTyped(json, false);
+}
+function LocationDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    name: json["name"],
+    key: json["key"],
+    isPersonalWorkspace: json["isPersonalWorkspace"]
+  };
+}
+// ../solution-sdk/generated/src/models/PackageInfo.ts
+function PackageInfoFromJSON(json) {
+  return PackageInfoFromJSONTyped(json, false);
+}
+function PackageInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["key"],
+    name: json["name"],
+    latestVersion: json["latestVersion"],
+    packageVersionKey: json["packageVersionKey"],
+    authorName: json["authorName"],
+    authorEmail: json["authorEmail"] == null ? undefined : json["authorEmail"],
+    publishDate: new Date(json["publishDate"]),
+    description: json["description"] == null ? undefined : json["description"],
+    releaseNotes: json["releaseNotes"] == null ? undefined : json["releaseNotes"],
+    state: ExtendedPackageVersionStateFromJSON(json["state"]),
+    solutionRootFolderName: json["solutionRootFolderName"],
+    hasUpgradeableDeployments: json["hasUpgradeableDeployments"]
+  };
+}
+// ../solution-sdk/generated/src/models/ResourceStats.ts
+function ResourceStatsFromJSON(json) {
+  return ResourceStatsFromJSONTyped(json, false);
+}
+function ResourceStatsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    count: json["count"],
+    kind: json["kind"],
+    serviceName: json["serviceName"]
+  };
+}
+
+// ../solution-sdk/generated/src/models/PackageVersionResourceDto.ts
+function PackageVersionResourceDtoFromJSON(json) {
+  return PackageVersionResourceDtoFromJSONTyped(json, false);
+}
+function PackageVersionResourceDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["key"],
+    name: json["name"],
+    kind: json["kind"],
+    type: json["type"] == null ? undefined : json["type"],
+    apiVersion: json["apiVersion"],
+    folders: json["folders"].map(FolderInfoFromJSON)
+  };
+}
+
+// ../solution-sdk/generated/src/models/PackageVersionComponentsDto.ts
+function PackageVersionComponentsDtoFromJSON(json) {
+  return PackageVersionComponentsDtoFromJSONTyped(json, false);
+}
+function PackageVersionComponentsDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    count: json["count"],
+    resources: json["resources"].map(PackageVersionResourceDtoFromJSON),
+    stats: json["stats"].map(ResourceStatsFromJSON)
+  };
+}
+// ../solution-sdk/generated/src/models/PackageVersionInfoDto.ts
+function PackageVersionInfoDtoFromJSON(json) {
+  return PackageVersionInfoDtoFromJSONTyped(json, false);
+}
+function PackageVersionInfoDtoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["key"],
+    packageName: json["packageName"],
+    packageVersion: json["packageVersion"],
+    publishDate: new Date(json["publishDate"]),
+    authorName: json["authorName"],
+    authorEmail: json["authorEmail"] == null ? undefined : json["authorEmail"],
+    description: json["description"] == null ? undefined : json["description"],
+    releaseNotes: json["releaseNotes"] == null ? undefined : json["releaseNotes"],
+    state: ExtendedPackageVersionStateFromJSON(json["state"]),
+    solutionRootFolderName: json["solutionRootFolderName"],
+    locationKey: json["locationKey"] == null ? undefined : json["locationKey"],
+    components: json["components"] == null ? undefined : PackageVersionComponentsDtoFromJSON(json["components"])
+  };
+}
+// ../solution-sdk/generated/src/apis/ConfigurationsApi.ts
+class ConfigurationsApi extends BaseAPI {
+  async configurationsPostRaw(requestParameters, initOverrides) {
+    if (requestParameters["createConfigurationCommand"] == null) {
+      throw new RequiredError("createConfigurationCommand", 'Required parameter "createConfigurationCommand" was null or undefined when calling configurationsPost().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/configurations`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreateConfigurationCommandToJSON(requestParameters["createConfigurationCommand"])
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  async configurationsPost(requestParameters, initOverrides) {
+    const response = await this.configurationsPostRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+
+// ../solution-sdk/generated/src/apis/DeploymentsApi.ts
+class DeploymentsApi extends BaseAPI {
+  async deploymentsDeployRaw(requestParameters, initOverrides) {
+    if (requestParameters["deploymentAutoRequest"] == null) {
+      throw new RequiredError("deploymentAutoRequest", 'Required parameter "deploymentAutoRequest" was null or undefined when calling deploymentsDeploy().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xUIPATHFolderKey"] != null) {
+      headerParameters["X-UIPATH-FolderKey"] = String(requestParameters["xUIPATHFolderKey"]);
+    }
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/deployments/deploy`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: DeploymentAutoRequestToJSON(requestParameters["deploymentAutoRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => DeploymentDtoFromJSON(jsonValue));
+  }
+  async deploymentsDeploy(requestParameters, initOverrides) {
+    const response = await this.deploymentsDeployRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async deploymentsGetByKeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["deploymentKey"] == null) {
+      throw new RequiredError("deploymentKey", 'Required parameter "deploymentKey" was null or undefined when calling deploymentsGetByKey().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/deployments/{deploymentKey}`;
+    urlPath = urlPath.replace(`{${"deploymentKey"}}`, encodeURIComponent(String(requestParameters["deploymentKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => DeploymentItemDtoFromJSON(jsonValue));
+  }
+  async deploymentsGetByKey(requestParameters, initOverrides) {
+    const response = await this.deploymentsGetByKeyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async deploymentsPostRaw(requestParameters, initOverrides) {
+    if (requestParameters["deploymentRequest"] == null) {
+      throw new RequiredError("deploymentRequest", 'Required parameter "deploymentRequest" was null or undefined when calling deploymentsPost().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/deployments`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: DeploymentRequestToJSON(requestParameters["deploymentRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => DeploymentItemDtoFromJSON(jsonValue));
+  }
+  async deploymentsPost(requestParameters, initOverrides) {
+    const response = await this.deploymentsPostRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async deploymentsUpgradeRaw(requestParameters, initOverrides) {
+    if (requestParameters["deploymentKey"] == null) {
+      throw new RequiredError("deploymentKey", 'Required parameter "deploymentKey" was null or undefined when calling deploymentsUpgrade().');
+    }
+    const queryParameters = {};
+    if (requestParameters["packageVersionKey"] != null) {
+      queryParameters["packageVersionKey"] = requestParameters["packageVersionKey"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/deployments/{deploymentKey}/upgrade`;
+    urlPath = urlPath.replace(`{${"deploymentKey"}}`, encodeURIComponent(String(requestParameters["deploymentKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: DeploymentUpgradeRequestToJSON(requestParameters["deploymentUpgradeRequest"])
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => DeploymentItemDtoFromJSON(jsonValue));
+  }
+  async deploymentsUpgrade(requestParameters, initOverrides) {
+    const response = await this.deploymentsUpgradeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+
+// ../solution-sdk/generated/src/apis/PackagesApi.ts
+class PackagesApi extends BaseAPI {
+  async packagesDeletePackageRaw(requestParameters, initOverrides) {
+    if (requestParameters["packageKey"] == null) {
+      throw new RequiredError("packageKey", 'Required parameter "packageKey" was null or undefined when calling packagesDeletePackage().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/{packageKey}`;
+    urlPath = urlPath.replace(`{${"packageKey"}}`, encodeURIComponent(String(requestParameters["packageKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async packagesDeletePackage(requestParameters, initOverrides) {
+    await this.packagesDeletePackageRaw(requestParameters, initOverrides);
+  }
+  async packagesDeleteVersionRaw(requestParameters, initOverrides) {
+    if (requestParameters["packageVersionKey"] == null) {
+      throw new RequiredError("packageVersionKey", 'Required parameter "packageVersionKey" was null or undefined when calling packagesDeleteVersion().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/versions/{packageVersionKey}`;
+    urlPath = urlPath.replace(`{${"packageVersionKey"}}`, encodeURIComponent(String(requestParameters["packageVersionKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  async packagesDeleteVersion(requestParameters, initOverrides) {
+    await this.packagesDeleteVersionRaw(requestParameters, initOverrides);
+  }
+  async packagesDownloadRaw(requestParameters, initOverrides) {
+    if (requestParameters["packageVersionKey"] == null) {
+      throw new RequiredError("packageVersionKey", 'Required parameter "packageVersionKey" was null or undefined when calling packagesDownload().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/{packageVersionKey}/download`;
+    urlPath = urlPath.replace(`{${"packageVersionKey"}}`, encodeURIComponent(String(requestParameters["packageVersionKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => BlobFileAccessDtoFromJSON(jsonValue));
+  }
+  async packagesDownload(requestParameters, initOverrides) {
+    const response = await this.packagesDownloadRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async packagesGetPackageRaw(requestParameters, initOverrides) {
+    if (requestParameters["packageKey"] == null) {
+      throw new RequiredError("packageKey", 'Required parameter "packageKey" was null or undefined when calling packagesGetPackage().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/{packageKey}`;
+    urlPath = urlPath.replace(`{${"packageKey"}}`, encodeURIComponent(String(requestParameters["packageKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PackageInfoFromJSON(jsonValue));
+  }
+  async packagesGetPackage(requestParameters, initOverrides) {
+    const response = await this.packagesGetPackageRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async packagesGetPublishLocationsRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/publish-locations`;
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(LocationDtoFromJSON));
+  }
+  async packagesGetPublishLocations(requestParameters = {}, initOverrides) {
+    const response = await this.packagesGetPublishLocationsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async packagesGetVersionRaw(requestParameters, initOverrides) {
+    if (requestParameters["packageVersionKey"] == null) {
+      throw new RequiredError("packageVersionKey", 'Required parameter "packageVersionKey" was null or undefined when calling packagesGetVersion().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/versions/{packageVersionKey}`;
+    urlPath = urlPath.replace(`{${"packageVersionKey"}}`, encodeURIComponent(String(requestParameters["packageVersionKey"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    }, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PackageVersionInfoDtoFromJSON(jsonValue));
+  }
+  async packagesGetVersion(requestParameters, initOverrides) {
+    const response = await this.packagesGetVersionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  async packagesUploadRaw(requestParameters, initOverrides) {
+    const queryParameters = {};
+    if (requestParameters["locationKey"] != null) {
+      queryParameters["locationKey"] = requestParameters["locationKey"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/zip";
+    if (requestParameters["xUipathAsVersion"] != null) {
+      headerParameters["x-uipath-as-version"] = String(requestParameters["xUipathAsVersion"]);
+    }
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("Bearer", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/packages/upload`;
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    }, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  async packagesUpload(requestParameters = {}, initOverrides) {
+    const response = await this.packagesUploadRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+}
+// ../solution-sdk/package.json
+var package_default = {
+  name: "@uipath/solution-sdk",
+  license: "MIT",
+  version: "1.201.0-preview.121",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/solution-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "solution",
+    "sdk"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./resources": {
+      types: "./dist/src/resources/index.d.ts",
+      default: "./dist/resources/index.js"
+    },
+    "./auth": {
+      types: "./dist/src/solution-auth.d.ts",
+      default: "./dist/solution-auth.js"
+    }
+  },
+  bin: {
+    "generate-sdk": "./dist/scripts/generate-sdk.js"
+  },
+  files: [
+    "dist"
+  ],
+  private: false,
+  scripts: {
+    build: "bun build ./src/index.ts ./src/resources/index.ts ./src/solution-auth.ts --outdir dist --format esm --target node --sourcemap=linked && bun build ./src/scripts/generate-sdk.ts --outdir dist/scripts --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    generate: "bun run src/scripts/generate-sdk.ts",
+    lint: "biome check .",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  devDependencies: {
+    "@openapitools/openapi-generator-cli": "^2.31.1",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/orchestrator-sdk": "workspace:*",
+    "@uipath/resource-builder-sdk": "^2025.11.0-alpha4202-3459",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/studioweb-sdk": "workspace:*",
+    "@types/node": "^25.5.2",
+    fflate: "^0.8.2",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../solution-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
+installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
+
+// ../studioweb-sdk/generated/src/runtime.ts
+var BASE_PATH2 = "https://alpha.uipath.com/studio_/backend".replace(/\/+$/, "");
+
+class Configuration2 {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH2;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring2;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig2 = new Configuration2;
+
+class BaseAPI2 {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig2) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI2.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError2(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData2(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob2(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError2(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob2(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData2(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError2 extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError2 extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+function querystring2(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey2(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey2(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey2(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring2(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+// ../solution-sdk/src/zip-utils.ts
+var DEFAULT_EXCLUDED_DIR_NAMES = new Set([
+  ".venv",
+  "node_modules",
+  "__pycache__",
+  ".git"
+]);
+var DEFAULT_EXCLUDED_FILE_PATTERNS = [
+  /^\.env($|\..+)/
+];
+function isDefaultExcludedFileName(name) {
+  for (const pattern of DEFAULT_EXCLUDED_FILE_PATTERNS) {
+    if (pattern.test(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+var UIPIGNORE_FILENAME = ".uipignore";
+function parseUipignore(body) {
+  const names = new Set;
+  for (const rawLine of body.split(/\r?\n/)) {
+    const line = rawLine.split("#")[0]?.trim();
+    if (!line) {
+      continue;
+    }
+    if (line.includes("/") || line.includes("\\")) {
+      continue;
+    }
+    names.add(line);
+  }
+  return names;
+}
+async function collectTree(fs, dir, options = {}) {
+  const files = [];
+  const emptyDirs = [];
+  const excluded = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
+  if (options.additionalExcludeDirs) {
+    for (const name of options.additionalExcludeDirs) {
+      excluded.add(name);
+    }
+  }
+  async function walk(current, isRoot) {
+    const entries = await fs.readdir(current);
+    if (entries.length === 0) {
+      if (!isRoot) {
+        emptyDirs.push(current);
+      }
+      return;
+    }
+    for (const entryName of entries) {
+      const fullPath = fs.path.join(current, entryName);
+      const entryStat = await fs.stat(fullPath);
+      if (entryStat?.isDirectory()) {
+        if (excluded.has(entryName)) {
+          continue;
+        }
+        await walk(fullPath, false);
+      } else if (entryStat?.isFile()) {
+        if (isDefaultExcludedFileName(entryName)) {
+          continue;
+        }
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir, true);
+  return { files, emptyDirs };
+}
+async function createZipFromDir(fs, dir, options = {}) {
+  const { files, emptyDirs } = await collectTree(fs, dir, options);
+  const zippable = {};
+  for (const filePath of files) {
+    const relPath = fs.path.relative(dir, filePath).replace(/\\/g, "/");
+    const data = await fs.readFile(filePath);
+    if (data) {
+      zippable[relPath] = new Uint8Array(data);
+    }
+  }
+  for (const emptyDir of emptyDirs) {
+    const relPath = fs.path.relative(dir, emptyDir).replace(/\\/g, "/");
+    if (!relPath) {
+      continue;
+    }
+    zippable[`${relPath}/`] = new Uint8Array(0);
+  }
+  return zipSync(zippable, { level: 6 });
+}
+
+// ../solution-sdk/src/bundle-service.ts
+async function readUipignore(fs, dir) {
+  const ignorePath = fs.path.join(dir, UIPIGNORE_FILENAME);
+  if (!await fs.exists(ignorePath)) {
+    return new Set;
+  }
+  try {
+    const body = await fs.readFile(ignorePath, "utf-8");
+    if (!body) {
+      return new Set;
+    }
+    return parseUipignore(body);
+  } catch (err) {
+    logger.warn(`Could not read ${UIPIGNORE_FILENAME}; ignoring it: ${String(err)}`);
+    return new Set;
+  }
+}
+async function mergeProjectUipignore(fs, projectPath, projectLabel, solutionExcludeDirs) {
+  const projectExtra = await readUipignore(fs, projectPath);
+  if (projectExtra.size === 0) {
+    return solutionExcludeDirs;
+  }
+  const merged = new Set(solutionExcludeDirs);
+  for (const name of projectExtra) {
+    merged.add(name);
+  }
+  logger.info(`[${projectLabel}] Applying ${projectExtra.size} extra exclude(s) from project ${UIPIGNORE_FILENAME}: ${[...projectExtra].join(", ")}`);
+  return merged;
+}
+var toForwardSlash = (p) => p.replace(/\\/g, "/");
+async function mirrorTree(fs, srcDir, relativeBase, destBaseDir, additionalExcludeDirs) {
+  const { files, emptyDirs } = await collectTree(fs, srcDir, {
+    additionalExcludeDirs
+  });
+  if (files.length === 0 && emptyDirs.length === 0) {
+    const rootRel = fs.path.relative(relativeBase, srcDir);
+    if (rootRel) {
+      await fs.mkdir(fs.path.join(destBaseDir, rootRel));
+    }
+    return;
+  }
+  for (const f of files) {
+    const relPath = fs.path.relative(relativeBase, f);
+    const destPath = fs.path.join(destBaseDir, relPath);
+    const data = await fs.readFile(f);
+    if (data) {
+      await fs.writeFile(destPath, data);
+    } else {
+      logger.warn(`Skipping empty or unreadable file: ${f}`);
+    }
+  }
+  for (const dir of emptyDirs) {
+    const relPath = fs.path.relative(relativeBase, dir);
+    if (!relPath) {
+      continue;
+    }
+    await fs.mkdir(fs.path.join(destBaseDir, relPath));
+  }
+}
+async function flattenProjectDir(fs, srcProjectDir, destProjectDir, additionalExcludeDirs) {
+  await fs.mkdir(destProjectDir);
+  const topLevelExclude = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
+  if (additionalExcludeDirs) {
+    for (const name of additionalExcludeDirs) {
+      topLevelExclude.add(name);
+    }
+  }
+  const entries = await fs.readdir(srcProjectDir);
+  for (const entryName of entries) {
+    const srcPath = fs.path.join(srcProjectDir, entryName);
+    const entryStat = await fs.stat(srcPath);
+    if (!entryStat) {
+      continue;
+    }
+    if (entryStat.isFile()) {
+      if (isDefaultExcludedFileName(entryName)) {
+        continue;
+      }
+      const data = await fs.readFile(srcPath);
+      if (data) {
+        await fs.writeFile(fs.path.join(destProjectDir, entryName), data);
+      }
+    } else if (entryStat.isDirectory()) {
+      if (topLevelExclude.has(entryName)) {
+        continue;
+      }
+      if (entryName === "content" || entryName === "flow_files") {
+        await mirrorTree(fs, srcPath, srcPath, destProjectDir, additionalExcludeDirs);
+      } else {
+        await mirrorTree(fs, srcPath, srcProjectDir, destProjectDir, additionalExcludeDirs);
+      }
+    }
+  }
+}
+async function bundleSolution(fs, solutionDir, outputDir, outputName) {
+  const resolvedPath = fs.path.resolve(solutionDir);
+  const solStat = await fs.stat(resolvedPath);
+  if (!solStat) {
+    throw new Error(`Path not found: ${resolvedPath}`);
+  }
+  if (!solStat.isDirectory()) {
+    throw new Error(`Not a directory: ${resolvedPath}. Provide the solution directory containing a .uipx file.`);
+  }
+  const { uipx, uipxFileName } = await readUipxFile(fs, resolvedPath);
+  const additionalExcludeDirs = await readUipignore(fs, resolvedPath);
+  if (additionalExcludeDirs.size > 0) {
+    logger.info(`Applying ${additionalExcludeDirs.size} extra exclude(s) from .uipignore: ${[...additionalExcludeDirs].join(", ")}`);
+  }
+  const effectiveExclude = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
+  for (const name of additionalExcludeDirs) {
+    effectiveExclude.add(name);
+  }
+  for (const project of uipx.Projects) {
+    project.ProjectRelativePath = toForwardSlash(project.ProjectRelativePath);
+  }
+  const solutionStorage = {
+    SolutionId: uipx.SolutionId,
+    Projects: uipx.Projects.map((p) => ({
+      ProjectId: p.Id,
+      ProjectRelativePath: p.ProjectRelativePath
+    }))
+  };
+  const solutionName = outputName || fs.path.basename(uipxFileName, ".uipx");
+  const stagingDir = fs.path.join(resolvedPath, `.uis-staging-${Date.now()}`);
+  await fs.mkdir(stagingDir);
+  try {
+    await fs.writeFile(fs.path.join(stagingDir, "SolutionStorage.json"), JSON.stringify(solutionStorage));
+    await fs.writeFile(fs.path.join(stagingDir, uipxFileName), JSON.stringify(uipx));
+    for (const project of uipx.Projects) {
+      const projectDir = fs.path.dirname(project.ProjectRelativePath);
+      const srcProjectPath = fs.path.join(resolvedPath, projectDir);
+      const projectStat = await fs.stat(srcProjectPath);
+      if (!projectStat) {
+        throw new Error(`Project directory not found: ${srcProjectPath}`);
+      }
+      const projectExcludeDirs = await mergeProjectUipignore(fs, srcProjectPath, projectDir, additionalExcludeDirs);
+      await flattenProjectDir(fs, srcProjectPath, fs.path.join(stagingDir, projectDir), projectExcludeDirs);
+    }
+    const resourcesPath = fs.path.join(resolvedPath, "resources");
+    if (!effectiveExclude.has("resources") && await fs.exists(resourcesPath)) {
+      await mirrorTree(fs, resourcesPath, resolvedPath, stagingDir, additionalExcludeDirs);
+    }
+    const userProfilePath = fs.path.join(resolvedPath, "userProfile");
+    if (!effectiveExclude.has("userProfile") && await fs.exists(userProfilePath)) {
+      await mirrorTree(fs, userProfilePath, resolvedPath, stagingDir, additionalExcludeDirs);
+    }
+    const resolvedOutputDir = fs.path.resolve(outputDir);
+    if (!await fs.exists(resolvedOutputDir)) {
+      await fs.mkdir(resolvedOutputDir);
+    }
+    const uisPath = fs.path.join(resolvedOutputDir, `${solutionName}.uis`);
+    const zipData = await createZipFromDir(fs, stagingDir);
+    await fs.writeFile(uisPath, zipData);
+    const uipxPath = fs.path.join(resolvedPath, uipxFileName);
+    return {
+      uisPath,
+      solutionName,
+      solutionId: uipx.SolutionId,
+      uipxPath,
+      projects: uipx.Projects.map((p) => ({
+        Name: fs.path.dirname(p.ProjectRelativePath),
+        Type: p.Type
+      }))
+    };
+  } finally {
+    await fs.rm(stagingDir);
+  }
+}
+// ../solution-sdk/src/project-debug-status.ts
+var SUCCEEDED = "creationsucceeded";
+var TERMINAL = new Set([SUCCEEDED, "creationfailed", "validationfailed"]);
+// ../solution-sdk/src/upload-service.ts
+class HttpError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+var DEFAULT_UPLOAD_TIMEOUT_MS = 120000;
+function resolveUploadTimeoutMs() {
+  const raw = Number(process.env?.UIPATH_SOLUTION_UPLOAD_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_UPLOAD_TIMEOUT_MS;
+}
+function formatTimeout(timeoutMs) {
+  return timeoutMs < 1000 ? `${Math.round(timeoutMs)}ms` : `${Math.round(timeoutMs / 1000)}s`;
+}
+function timeoutMessage(what, timeoutMs) {
+  return `${what} timed out after ${formatTimeout(timeoutMs)} — the connection ` + `stalled with no response from Studio Web. Retry the command; if it keeps ` + `timing out, check connectivity (VPN/proxy) to the tenant, or raise the ` + `ceiling with UIPATH_SOLUTION_UPLOAD_TIMEOUT_MS.`;
+}
+function isTimeoutError(error) {
+  let current = error;
+  for (let depth = 0;depth < 5 && current instanceof Error; depth += 1) {
+    if (current.name === "TimeoutError")
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+async function fetchWithUploadTimeout(url, init, what) {
+  const timeoutMs = resolveUploadTimeoutMs();
+  const [error, response] = await catchError(fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+  if (error) {
+    if (isTimeoutError(error)) {
+      throw new Error(timeoutMessage(what, timeoutMs));
+    }
+    throw error;
+  }
+  return response;
+}
+async function importSolution(config, organizationName, fileBuffer, fileName) {
+  const importUrl = `${config.baseUrl}/${organizationName}/studio_/backend/api/Solution/Import?desktopJit=true&useFileRest=true&enableUnifiedBuild=true`;
+  const formData = new FormData;
+  const fileBlob = new Blob([fileBuffer], {
+    type: "application/octet-stream"
+  });
+  formData.append("uploadFile", fileBlob, fileName);
+  formData.append("telemetryData", JSON.stringify({ FirstRun: false }));
+  const headers = addSdkUserAgentHeader({
+    Authorization: `Bearer ${config.authToken}`
+  }, SDK_USER_AGENT);
+  if (config.tenantId) {
+    headers["x-uipath-tenantid"] = config.tenantId;
+  }
+  const response = await fetchWithUploadTimeout(importUrl, { method: "POST", headers, body: formData }, "Studio Web solution import");
+  if (!response.ok) {
+    const text = await response.text();
+    throw new HttpError(response.status, `Import failed (${response.status}): ${text}`);
+  }
+  return await response.json();
+}
+async function overwriteSolution(config, organizationName, fileBuffer, fileName, solutionId) {
+  const overwriteUrl = `${config.baseUrl}/${organizationName}/studio_/backend/api/Solution/${solutionId}/Overwrite`;
+  const formData = new FormData;
+  const fileBlob = new Blob([fileBuffer], {
+    type: "application/octet-stream"
+  });
+  formData.append("UploadFile", fileBlob, fileName);
+  const headers = addSdkUserAgentHeader({
+    Authorization: `Bearer ${config.authToken}`
+  }, SDK_USER_AGENT);
+  if (config.tenantId) {
+    headers["x-uipath-tenantid"] = config.tenantId;
+  }
+  const response = await fetchWithUploadTimeout(overwriteUrl, { method: "POST", headers, body: formData }, "Studio Web solution overwrite");
+  if (!response.ok) {
+    const text = await response.text();
+    throw new HttpError(response.status, `Overwrite failed (${response.status}): ${text}`);
+  }
+  return await response.json();
+}
+async function uploadOrOverwriteSolution(config, organizationName, fileBufferOrPath, solutionId, fs) {
+  let fileBuffer;
+  let fileName;
+  if (typeof fileBufferOrPath === "string") {
+    if (!fs) {
+      throw new Error("IFileSystem is required when passing a file path to uploadOrOverwriteSolution");
+    }
+    const content = await fs.readFile(fileBufferOrPath);
+    if (content === null) {
+      throw new Error(`Failed to read file: ${fileBufferOrPath}`);
+    }
+    fileBuffer = new Uint8Array(content);
+    fileName = fs.path.basename(fileBufferOrPath);
+  } else {
+    fileBuffer = fileBufferOrPath;
+    fileName = "solution.uis";
+  }
+  if (solutionId) {
+    logger.info(`Attempting to overwrite existing solution ${solutionId} on Studio Web...`);
+    const [overwriteError, overwriteResult] = await catchError(overwriteSolution(config, organizationName, fileBuffer, fileName, solutionId));
+    if (!overwriteError) {
+      logger.info("Solution overwritten successfully.");
+      return overwriteResult;
+    }
+    if (overwriteError instanceof HttpError && overwriteError.status === 404) {
+      logger.info(`Solution ${solutionId} not found on Studio Web. Importing as new solution...`);
+    } else {
+      throw overwriteError;
+    }
+  }
+  logger.info("Importing new solution to Studio Web...");
+  return importSolution(config, organizationName, fileBuffer, fileName);
+}
+// src/services/pack-helpers.ts
+var import_adm_zip = __toESM(require_adm_zip(), 1);
+async function collectProjectFiles(rootDir) {
+  const files = [];
+  await collectRecursive(rootDir, rootDir, files);
+  return files;
+}
+async function collectRecursive(rootDir, currentDir, files) {
+  const fs = getFileSystem();
+  const entries = await fs.readdir(currentDir);
+  for (const entry of entries) {
+    const fullPath = fs.path.join(currentDir, entry);
+    const stats = await fs.stat(fullPath);
+    if (stats?.isDirectory()) {
+      await collectRecursive(rootDir, fullPath, files);
+    } else if (stats) {
+      files.push(fs.path.relative(rootDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+}
+function matchesExclude(relPath, exclude) {
+  for (const pattern of exclude) {
+    const cleaned = pattern.replace(/^\.\//, "").replace(/\/\*$/, "");
+    if (cleaned.startsWith("*")) {
+      const suffix = cleaned.slice(1).replace(/^\//, "");
+      if (relPath.includes(`/${suffix}/`) || relPath.includes(`/${suffix}`)) {
+        return true;
+      }
+    }
+    if (relPath === cleaned || relPath.startsWith(`${cleaned}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function createArchive(sourceDir, outputPath, exclude) {
+  const fs = getFileSystem();
+  const zip = new import_adm_zip.default;
+  const files = await collectProjectFiles(sourceDir);
+  for (const relPath of files) {
+    if (exclude && matchesExclude(relPath, exclude)) {
+      continue;
+    }
+    const fullPath = fs.path.join(sourceDir, relPath);
+    const dirInZip = relPath.includes("/") ? relPath.substring(0, relPath.lastIndexOf("/")) : "";
+    zip.addLocalFile(fullPath, dirInZip);
+  }
+  zip.writeZip(outputPath);
+}
+async function extractArchive(archivePath, destDir) {
+  const zip = new import_adm_zip.default(archivePath);
+  zip.extractAllTo(destDir, true);
+}
+
+// src/services/agent-debug-service.ts
+import { randomUUID } from "node:crypto";
+
+// src/services/agent-local-workspace-eval-preparer.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+  return UUID_PATTERN.test(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toForwardSlash2(path) {
+  return path.replace(/\\/g, "/");
+}
+async function resolveStudioWebConfig() {
+  const [loginError, login] = await catchError(getLoginStatusAsync());
+  if (loginError) {
+    throw new Error(loginError.message);
+  }
+  if (login.loginStatus !== "Logged in" || !login.baseUrl) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  if (!login.accessToken) {
+    throw new Error("Access token not available from login.");
+  }
+  if (!login.organizationName) {
+    throw new Error("Organization name not available from login. Required for Studio Web evaluation.");
+  }
+  return {
+    baseUrl: login.baseUrl,
+    tenantId: login.tenantId,
+    authToken: login.accessToken,
+    organizationName: login.organizationName
+  };
+}
+
+class AgentLocalWorkspaceEvalPreparer {
+  fs;
+  constructor(fs = getFileSystem()) {
+    this.fs = fs;
+  }
+  async isLocalWorkspace(projectPath) {
+    return await this.readLocalWorkspaceMarker(projectPath) !== undefined;
+  }
+  async prepare(projectPath, config, existingSolutionIdOverride) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const marker = await this.readLocalWorkspaceMarker(absoluteProjectPath);
+    const packageRoot = marker?.rootPath ?? absoluteProjectPath;
+    const projectService = new AgentProjectService;
+    const agentDir = await projectService.resolveAgentDir(absoluteProjectPath);
+    const agent = await projectService.readAgentJson(absoluteProjectPath);
+    const projectFilePath = this.fs.path.join(agentDir, "project.uiproj");
+    if (!await this.fs.exists(projectFilePath)) {
+      throw new Error(`Not a valid agent project directory: missing project.uiproj in ${agentDir}`);
+    }
+    const projectFileContent = await this.fs.readFile(projectFilePath, "utf-8");
+    const [projectFileError, parsedProjectFile] = catchError(() => JSON.parse(String(projectFileContent)));
+    if (projectFileError || !isRecord(parsedProjectFile)) {
+      throw new Error(`Invalid project.uiproj in ${agentDir}: ${projectFileError?.message ?? "expected a JSON object"}`);
+    }
+    const projectFile = {
+      Name: typeof parsedProjectFile.Name === "string" ? parsedProjectFile.Name : undefined
+    };
+    const solutionInfo = await findSolutionFile(this.fs, agentDir);
+    const solutionId = existingSolutionIdOverride ?? marker?.solutionId ?? solutionInfo?.solutionId;
+    const solutionName = projectFile.Name ?? agent.metadata.name ?? this.fs.path.basename(agentDir);
+    const safeSolutionName = solutionName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const stagingDir = this.fs.path.join(this.fs.env.tmpdir(), `.agent-eval-staging-${safeSolutionName}-${Date.now()}`);
+    await this.fs.mkdir(stagingDir);
+    const uisPath = this.fs.path.join(stagingDir, `${safeSolutionName}.uis`);
+    try {
+      logger.info("Building agent package for local workspace eval...");
+      await createArchive(packageRoot, uisPath, [
+        "./.agent-builder/*",
+        "*/.agent-builder/*",
+        ".sw-path-marker",
+        "*/.sw-path-marker"
+      ]);
+      logger.info("Uploading local workspace agent for eval...");
+      const importResult = await uploadOrOverwriteSolution({
+        baseUrl: config.baseUrl,
+        tenantId: config.tenantId,
+        authToken: config.authToken
+      }, config.organizationName, uisPath, solutionId, this.fs);
+      const matchedProject = this.resolveImportedProject(importResult, solutionName);
+      await this.persistSolutionStorage(projectService, absoluteProjectPath, packageRoot, projectFilePath, importResult.id, agent.projectId, matchedProject.id);
+      if (packageRoot !== absoluteProjectPath) {
+        await this.persistSolutionStorage(projectService, packageRoot, packageRoot, projectFilePath, importResult.id, agent.projectId, matchedProject.id);
+      }
+      await updateSolutionFile(this.fs, agentDir, importResult.id);
+      if (marker) {
+        await this.updateLocalWorkspaceMarker(marker.rootPath, importResult.id);
+      }
+      return {
+        solutionId: importResult.id,
+        agentProjectId: matchedProject.id
+      };
+    } finally {
+      const [cleanupError] = await catchError(this.fs.rm(stagingDir, { recursive: true }));
+      if (cleanupError) {
+        logger.warn(`Cleanup failed: ${cleanupError.message}`);
+      }
+    }
+  }
+  async readLocalWorkspaceMarker(projectPath) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const candidates = [
+      absoluteProjectPath,
+      this.fs.path.dirname(absoluteProjectPath)
+    ];
+    for (const candidate of candidates) {
+      const markerPath = this.fs.path.join(candidate, ".sw-path-marker");
+      if (!await this.fs.exists(markerPath)) {
+        continue;
+      }
+      const content = String(await this.fs.readFile(markerPath, "utf-8"));
+      const solutionId = content.trim();
+      return {
+        rootPath: candidate,
+        ...isUUID(solutionId) ? { solutionId } : {}
+      };
+    }
+    return;
+  }
+  resolveImportedProject(importResult, agentName) {
+    const exactProject = importResult.projects.find((project) => project.name === agentName);
+    if (exactProject?.id) {
+      return exactProject;
+    }
+    const [onlyProject] = importResult.projects;
+    if (importResult.projects.length === 1 && onlyProject?.id) {
+      return onlyProject;
+    }
+    throw new Error(`Upload response had ${importResult.projects.length} projects and none matched "${agentName}"; refusing to guess.`);
+  }
+  async persistSolutionStorage(projectService, storagePath, packageRoot, projectFilePath, solutionId, localProjectId, cloudProjectId) {
+    const projectRelativePath = toForwardSlash2(this.fs.path.relative(packageRoot, projectFilePath));
+    const projectEntry = {
+      ProjectId: localProjectId,
+      ProjectRelativePath: projectRelativePath || "project.uiproj",
+      CloudProjectId: cloudProjectId
+    };
+    const [, existingStorage] = await catchError(projectService.readSolutionStorage(storagePath));
+    const existingProjects = existingStorage?.Projects ?? [];
+    const projectIndex = existingProjects.findIndex((project) => project.ProjectId === localProjectId);
+    const projects = projectIndex === -1 ? [...existingProjects, projectEntry] : existingProjects.map((project, index) => index === projectIndex ? { ...project, ...projectEntry } : project);
+    await projectService.writeSolutionStorage(storagePath, {
+      SolutionId: solutionId,
+      Projects: projects
+    });
+  }
+  async updateLocalWorkspaceMarker(workspaceRoot, solutionId) {
+    await this.fs.writeFile(this.fs.path.join(workspaceRoot, ".sw-path-marker"), solutionId);
+  }
+}
+
+// src/services/agent-debug-service.ts
+class AgentDebugCancelledError extends Error {
+  jobKey;
+  constructor(jobKey) {
+    super(jobKey ? `Debug run cancelled. Job ${jobKey} may still be running on the serverless runtime.` : "Debug run cancelled before the job started.");
+    this.name = "AgentDebugCancelledError";
+    this.jobKey = jobKey;
+  }
+}
+var TERMINAL_STATES = new Set([
+  "Successful",
+  "Faulted",
+  "Stopped",
+  "Suspended"
+]);
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class AgentDebugService {
+  fs = getFileSystem();
+  projectService = new AgentProjectService;
+  async debug(options, auth) {
+    throwIfAborted(options.signal);
+    const projectId = await this.resolveProjectId(options.projectPath);
+    throwIfAborted(options.signal);
+    const folderKey = await this.resolvePersonalWorkspaceKey();
+    throwIfAborted(options.signal);
+    const { jobKey, traceId } = await asCancellation(() => this.startDebugJob(auth, folderKey, projectId, options.inputs, options.signal));
+    const job = await asCancellation(() => this.pollJob(auth, folderKey, jobKey, options), jobKey);
+    return {
+      jobKey,
+      traceId,
+      finalState: job.state,
+      success: job.state === "Successful",
+      output: job.output,
+      info: job.info
+    };
+  }
+  async resolveProjectId(projectPath) {
+    const preparer = new AgentLocalWorkspaceEvalPreparer;
+    if (await preparer.isLocalWorkspace(projectPath)) {
+      const [, storage] = await catchError(this.projectService.readSolutionStorage(projectPath));
+      const config = await resolveStudioWebConfig();
+      const prepared = await preparer.prepare(projectPath, config, storage?.SolutionId);
+      return prepared.agentProjectId;
+    }
+    return this.uploadSolutionAndResolveProjectId(projectPath);
+  }
+  async uploadSolutionAndResolveProjectId(projectPath) {
+    const solution = await findSolutionFile(this.fs, projectPath);
+    if (!solution) {
+      throw new Error(`No enclosing .uipx solution found for '${projectPath}'. Create one with 'uip solution init' and add the agent to it.`);
+    }
+    const config = await resolveStudioWebConfig();
+    const solutionDir = this.fs.path.resolve(projectPath, "..");
+    const tempDir = await this.fs.getTempDir();
+    try {
+      const bundle = await bundleSolution(this.fs, solutionDir, tempDir);
+      const importResult = await uploadOrOverwriteSolution(config, config.organizationName, bundle.uisPath, bundle.solutionId, this.fs);
+      if (importResult.id && bundle.uipxPath) {
+        await updateUipxSolutionId(this.fs, bundle.uipxPath, importResult.id);
+      }
+      const projectName = await this.readProjectName(projectPath);
+      const byName = importResult.projects.find((p) => p.name === projectName);
+      if (byName?.id) {
+        return byName.id;
+      }
+      const [only] = importResult.projects;
+      if (importResult.projects.length === 1 && only?.id) {
+        return only.id;
+      }
+      throw new Error(`Could not resolve the Studio Web project for "${projectName}": the upload returned ${importResult.projects.length} projects and none is named "${projectName}". Ensure the Name in project.uiproj matches the agent project in the solution.`);
+    } finally {
+      const [cleanupError] = await catchError(this.fs.rm(tempDir));
+      if (cleanupError) {
+        logger.debug(`Failed to clean up temp dir: ${cleanupError.message}`);
+      }
+    }
+  }
+  async readProjectName(projectPath) {
+    const [, content] = await catchError(this.fs.readFile(this.fs.path.join(projectPath, "project.uiproj"), "utf-8"));
+    const [, parsed] = catchError(() => JSON.parse(String(content)));
+    return parsed?.Name ?? this.fs.path.basename(projectPath);
+  }
+  async resolvePersonalWorkspaceKey() {
+    const wsApi = await createApiClient(PersonalWorkspacesApi, {});
+    const workspace = await wsApi.personalWorkspacesGetPersonalWorkspace();
+    if (!workspace?.key) {
+      throw new Error("Could not resolve your personal workspace. Ensure it is enabled for your account.");
+    }
+    return workspace.key;
+  }
+  orchestratorBaseUrl(auth) {
+    return `${auth.baseUrl}/${auth.organizationId}/${auth.tenantName}/orchestrator_`;
+  }
+  async startDebugJob(auth, folderKey, projectId, inputs, signal) {
+    const traceId = randomUUID();
+    const inputArguments = JSON.stringify({
+      Command: "debug",
+      EntryPoint: "agent.json",
+      Input: JSON.stringify(inputs),
+      args: "--attach=none"
+    });
+    const response = await fetch(`${this.orchestratorBaseUrl(auth)}/api/serverless/jobs`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${auth.accessToken}`,
+        "Content-Type": "application/json",
+        "X-UIPATH-FolderKey": folderKey
+      },
+      body: JSON.stringify({
+        JobType: "PythonAgent",
+        InputArguments: inputArguments,
+        Source: "StudioWeb",
+        RunAsMe: true,
+        EnvironmentVariables: `UIPATH_PROJECT_ID=${projectId}`,
+        TraceId: traceId,
+        Reference: randomUUID()
+      }),
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to start debug job: ${response.status} ${await response.text()}`);
+    }
+    const data = await response.json();
+    if (!data.key) {
+      throw new Error("Debug job started but no job key was returned.");
+    }
+    return { jobKey: data.key, traceId };
+  }
+  async pollJob(auth, folderKey, jobKey, options) {
+    const url = `${this.orchestratorBaseUrl(auth)}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${jobKey})`;
+    const headers = {
+      Authorization: `Bearer ${auth.accessToken}`,
+      "X-UIPATH-FolderKey": folderKey
+    };
+    let lastState = "";
+    let consecutiveErrors = 0;
+    const maxConsecutiveErrors = 3;
+    for (let poll = 0;poll < options.maxPolls; poll++) {
+      await delay(options.pollIntervalMs);
+      throwIfAborted(options.signal, jobKey);
+      const response = await fetch(url, {
+        headers,
+        signal: options.signal
+      });
+      if (!response.ok) {
+        consecutiveErrors++;
+        if (response.status < 500 || consecutiveErrors > maxConsecutiveErrors) {
+          const body = await response.text();
+          throw new Error(`Failed to poll debug job (HTTP ${response.status}): ${body.slice(0, 300)}`);
+        }
+        continue;
+      }
+      consecutiveErrors = 0;
+      const job = await response.json();
+      if (job.State !== lastState) {
+        lastState = job.State;
+        options.onState?.(job.State);
+      }
+      if (TERMINAL_STATES.has(job.State)) {
+        return {
+          state: job.State,
+          output: parseOutput(job.OutputArguments),
+          info: job.Info?.trim() || undefined
+        };
+      }
+    }
+    throw new Error(`Debug run did not reach a terminal state within the timeout (last state: ${lastState || "unknown"}). Increase --timeout and retry.`);
+  }
+}
+function throwIfAborted(signal, jobKey) {
+  if (signal?.aborted) {
+    throw new AgentDebugCancelledError(jobKey);
+  }
+}
+async function asCancellation(step, jobKey) {
+  try {
+    return await step();
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw new AgentDebugCancelledError(jobKey);
+    }
+    throw error;
+  }
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function parseOutput(outputArguments) {
+  if (!outputArguments) {
+    return;
+  }
+  const [error, parsed] = catchError(() => JSON.parse(outputArguments));
+  return error ? outputArguments : parsed;
+}
+
+export { Configuration, ConfigurationsApi, DeploymentsApi, PackagesApi, createArchive, extractArchive, resolveStudioWebConfig, AgentLocalWorkspaceEvalPreparer, AgentDebugCancelledError, AgentDebugService };
+
+//# debugId=9E43C54B7330E6BC64756E2164756E21