@hpcc-js/comms/dist/browser/index.js

hpcc-js - Communications

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { scopedLogger, join, promiseTimeout, exists, deepMixin, xml2json, StateObject, Cache, Graph, Subgraph as Subgraph$1, Vertex as Vertex$1, Edge as Edge$1, SAXStackParser, Stack, espTime2Seconds as espTime2Seconds$1, deepMixinT, XMLNode, debounce, Message, Dispatch } from "@hpcc-js/util";
const PKG_NAME = "@hpcc-js/comms";
const PKG_VERSION = "3.7.6";
const BUILD_VERSION = "3.9.0";
const logger$6 = scopedLogger("comms/connection.ts");
function instanceOfIOptions(object) {
  return "baseUrl" in object;
}
__name(instanceOfIOptions, "instanceOfIOptions");
const DefaultOptions = {
  type: "post",
  baseUrl: "",
  userID: "",
  password: "",
  rejectUnauthorized: true,
  timeoutSecs: 60
};
function instanceOfIConnection(object) {
  return typeof object.opts === "function" && typeof object.send === "function" && typeof object.clone === "function";
}
__name(instanceOfIConnection, "instanceOfIConnection");
function encode(uriComponent, encodeRequest) {
  return encodeRequest === void 0 || encodeRequest === true ? encodeURIComponent(uriComponent) : "" + uriComponent;
}
__name(encode, "encode");
function serializeRequest(obj, encodeRequest = true, prefix = "") {
  if (prefix) {
    prefix += ".";
  }
  if (typeof obj !== "object") {
    return encode(obj, encodeRequest);
  }
  const str = [];
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      if (obj[key] instanceof Array) {
        let includeItemCount = false;
        obj[key].forEach((row, i) => {
          if (typeof row === "object") {
            includeItemCount = true;
            str.push(serializeRequest(row, encodeRequest, prefix + encode(`${key}.${i}`, encodeRequest)));
          } else {
            str.push(prefix + encode(`${key}_i${i}`, encodeRequest) + "=" + serializeRequest(row, encodeRequest));
          }
        });
        if (includeItemCount) {
          str.push(prefix + encode(`${key}.itemcount`, encodeRequest) + "=" + obj[key].length);
        }
      } else if (typeof obj[key] === "object") {
        if (obj[key] && obj[key]["Item"] instanceof Array) {
          str.push(serializeRequest(obj[key]["Item"], encodeRequest, prefix + encode(key, encodeRequest)));
          str.push(prefix + encode(`${key}.itemcount`, encodeRequest) + "=" + obj[key]["Item"].length);
        } else {
          str.push(serializeRequest(obj[key], encodeRequest, prefix + encode(key, encodeRequest)));
        }
      } else if (obj[key] !== void 0) {
        str.push(prefix + encode(key, encodeRequest) + "=" + encode(obj[key], encodeRequest));
      } else {
        str.push(prefix + encode(key, encodeRequest));
      }
    }
  }
  return str.join("&");
}
__name(serializeRequest, "serializeRequest");
function deserializeResponse(body) {
  return JSON.parse(body);
}
__name(deserializeResponse, "deserializeResponse");
function jsonp(opts, action, request = {}, responseType = "json", header) {
  if (header) {
    console.warn("Header attributes ignored for JSONP connections");
  }
  return new Promise((resolve, reject) => {
    let respondedTimeout = opts.timeoutSecs * 1e3;
    const respondedTick = 5e3;
    const callbackName = "jsonp_callback_" + Math.round(Math.random() * 999999);
    window[callbackName] = function(response) {
      respondedTimeout = 0;
      doCallback();
      resolve(responseType === "json" && typeof response === "string" ? deserializeResponse(response) : response);
    };
    const script = document.createElement("script");
    let url = join(opts.baseUrl, action);
    url += url.indexOf("?") >= 0 ? "&" : "?";
    script.src = url + "jsonp=" + callbackName + "&" + serializeRequest(request, opts.encodeRequest);
    document.body.appendChild(script);
    const progress = setInterval(function() {
      if (respondedTimeout <= 0) {
        clearInterval(progress);
      } else {
        respondedTimeout -= respondedTick;
        if (respondedTimeout <= 0) {
          clearInterval(progress);
          logger$6.error("Request timeout:  " + script.src);
          doCallback();
          reject(Error("Request timeout:  " + script.src));
        } else {
          logger$6.debug("Request pending (" + respondedTimeout / 1e3 + " sec):  " + script.src);
        }
      }
    }, respondedTick);
    function doCallback() {
      delete window[callbackName];
      document.body.removeChild(script);
    }
    __name(doCallback, "doCallback");
  });
}
__name(jsonp, "jsonp");
function authHeader(opts) {
  return opts.userID ? { Authorization: `Basic ${btoa(`${opts.userID}:${opts.password}`)}` } : {};
}
__name(authHeader, "authHeader");
const _omitMap = {};
function doFetch(opts, action, requestInit, headersInit, responseType) {
  headersInit = {
    ...authHeader(opts),
    ...headersInit
  };
  requestInit = {
    credentials: _omitMap[opts.baseUrl] ? "omit" : "include",
    ...requestInit,
    headers: headersInit
  };
  if (fetch["__setGlobalDispatcher"]) {
    fetch["__setGlobalDispatcher"](fetch["__defaultAgent"]);
  }
  if (opts.baseUrl.indexOf("https:") === 0) {
    if (opts.rejectUnauthorized === false && fetch["__rejectUnauthorizedAgent"]) {
      if (fetch["__setGlobalDispatcher"]) {
        fetch["__setGlobalDispatcher"](fetch["__rejectUnauthorizedAgent"]);
      } else {
        requestInit["agent"] = fetch["__rejectUnauthorizedAgent"];
      }
    } else if (fetch["__trustwaveAgent"]) {
      requestInit["agent"] = fetch["__trustwaveAgent"];
    }
  }
  function handleResponse(response) {
    if (response.ok) {
      return responseType === "json" ? response.json() : response.text();
    }
    throw new Error(response.statusText);
  }
  __name(handleResponse, "handleResponse");
  return promiseTimeout(
    opts.timeoutSecs * 1e3,
    fetch(join(opts.baseUrl, action), requestInit).then(handleResponse).catch((e) => {
      requestInit.credentials = !_omitMap[opts.baseUrl] ? "omit" : "include";
      return fetch(join(opts.baseUrl, action), requestInit).then(handleResponse).then((responseBody) => {
        _omitMap[opts.baseUrl] = !_omitMap[opts.baseUrl];
        return responseBody;
      });
    })
  );
}
__name(doFetch, "doFetch");
function post(opts, action, request, responseType = "json", header) {
  if (request.upload_) {
    delete request.upload_;
    action += "?upload_";
  }
  let abortSignal;
  if (request.abortSignal_) {
    abortSignal = request.abortSignal_;
    delete request.abortSignal_;
  }
  return doFetch(opts, action, {
    method: "post",
    body: serializeRequest(request, opts.encodeRequest),
    signal: abortSignal
  }, {
    "Content-Type": "application/x-www-form-urlencoded",
    ...header
  }, responseType);
}
__name(post, "post");
function get(opts, action, request, responseType = "json", header) {
  let abortSignal;
  if (request.abortSignal_) {
    abortSignal = request.abortSignal_;
    delete request.abortSignal_;
  }
  return doFetch(opts, `${action}?${serializeRequest(request, opts.encodeRequest)}`, {
    method: "get",
    signal: abortSignal
  }, {
    ...header
  }, responseType);
}
__name(get, "get");
function send(opts, action, request, responseType = "json", header) {
  let retVal;
  switch (opts.type) {
    case "jsonp":
      retVal = jsonp(opts, action, request, responseType, header);
      break;
    case "get":
      retVal = get(opts, action, request, responseType, header);
      break;
    case "post":
    default:
      retVal = post(opts, action, request, responseType, header);
      break;
  }
  return retVal;
}
__name(send, "send");
let hookedSend = send;
function hookSend(newSend) {
  const retVal = hookedSend;
  if (newSend) {
    hookedSend = newSend;
  }
  return retVal;
}
__name(hookSend, "hookSend");
const _Connection = class _Connection {
  constructor(opts) {
    __publicField(this, "_opts");
    this.opts(opts);
  }
  get baseUrl() {
    return this._opts.baseUrl;
  }
  opts(_) {
    if (arguments.length === 0) return this._opts;
    this._opts = { ...DefaultOptions, ..._ };
    return this;
  }
  send(action, request, responseType = "json", header) {
    if (this._opts.hookSend) {
      return this._opts.hookSend(this._opts, action, request, responseType, hookedSend, header);
    }
    return hookedSend(this._opts, action, request, responseType, header);
  }
  clone() {
    return new _Connection(this.opts());
  }
};
__name(_Connection, "Connection");
let Connection = _Connection;
let createConnection = /* @__PURE__ */ __name(function(opts) {
  return new Connection(opts);
}, "createConnection");
function setTransportFactory(newFunc) {
  const retVal = createConnection;
  createConnection = newFunc;
  return retVal;
}
__name(setTransportFactory, "setTransportFactory");
function isArray(arg) {
  return Object.prototype.toString.call(arg) === "[object Array]";
}
__name(isArray, "isArray");
const _ESPExceptions = class _ESPExceptions extends Error {
  constructor(action, request, exceptions) {
    super("ESPException:  " + exceptions.Source);
    __publicField(this, "isESPExceptions", true);
    __publicField(this, "action");
    __publicField(this, "request");
    __publicField(this, "Source");
    __publicField(this, "Exception");
    this.action = action;
    this.request = request;
    this.Source = exceptions.Source;
    this.Exception = exceptions.Exception;
    if (exceptions.Exception.length) {
      this.message = `${exceptions.Exception[0].Code}:  ${exceptions.Exception[0].Message}`;
    } else {
      this.message = "";
    }
  }
};
__name(_ESPExceptions, "ESPExceptions");
let ESPExceptions = _ESPExceptions;
function isExceptions(err) {
  return err instanceof ESPExceptions || err.isESPExceptions && Array.isArray(err.Exception);
}
__name(isExceptions, "isExceptions");
function isConnection(optsConnection) {
  return optsConnection.send !== void 0;
}
__name(isConnection, "isConnection");
const _ESPConnection = class _ESPConnection {
  constructor(optsConnection, service, version) {
    __publicField(this, "_connection");
    __publicField(this, "_service");
    __publicField(this, "_version");
    this._connection = isConnection(optsConnection) ? optsConnection : createConnection(optsConnection);
    this._service = service;
    this._version = version;
  }
  get baseUrl() {
    return this._connection.opts().baseUrl;
  }
  service(_) {
    if (_ === void 0) return this._service;
    this._service = _;
    return this;
  }
  version(_) {
    if (_ === void 0) return this._version;
    this._version = _;
    return this;
  }
  toESPStringArray(target, arrayName) {
    if (isArray(target[arrayName])) {
      for (let i = 0; i < target[arrayName].length; ++i) {
        target[arrayName + "_i" + i] = target[arrayName][i];
      }
      delete target[arrayName];
    }
    return target;
  }
  opts(_) {
    if (_ === void 0) return this._connection.opts();
    this._connection.opts(_);
    return this;
  }
  send(action, _request = {}, espResponseType = "json", largeUpload = false, abortSignal, espResponseField) {
    const request = { ..._request, ...{ ver_: this._version } };
    if (largeUpload) {
      request["upload_"] = true;
    }
    if (abortSignal) {
      request["abortSignal_"] = abortSignal;
    }
    let serviceAction;
    let responseType = "json";
    switch (espResponseType) {
      case "text":
        serviceAction = join(this._service, action);
        responseType = "text";
        break;
      case "xsd":
        serviceAction = join(this._service, action + ".xsd");
        responseType = "text";
        break;
      case "json2":
        serviceAction = join(this._service, action + "/json");
        espResponseType = "json";
        const actionParts = action.split("/");
        action = actionParts.pop();
        break;
      default:
        serviceAction = join(this._service, action + ".json");
    }
    return this._connection.send(serviceAction, request, responseType).then((response) => {
      if (espResponseType === "json") {
        let retVal;
        if (response && response.Exceptions) {
          throw new ESPExceptions(action, request, response.Exceptions);
        } else if (response) {
          retVal = response[espResponseField || action + "Response"];
        }
        if (!retVal) {
          throw new ESPExceptions(action, request, {
            Source: "ESPConnection.send",
            Exception: [{ Code: 0, Message: "Missing Response" }]
          });
        }
        return retVal;
      }
      return response;
    });
  }
  clone() {
    return new _ESPConnection(this._connection.clone(), this._service, this._version);
  }
};
__name(_ESPConnection, "ESPConnection");
let ESPConnection = _ESPConnection;
const _Service = class _Service {
  constructor(optsConnection, service, version) {
    __publicField(this, "_connection");
    this._connection = new ESPConnection(optsConnection, service, version);
  }
  get baseUrl() {
    return this._connection.opts().baseUrl;
  }
  opts() {
    return this._connection.opts();
  }
  connection() {
    return this._connection.clone();
  }
};
__name(_Service, "Service");
let Service = _Service;
var FileSpray;
((FileSpray2) => {
  ((DFUWUActions2) => {
    DFUWUActions2["Delete"] = "Delete";
    DFUWUActions2["Protect"] = "Protect";
    DFUWUActions2["Unprotect"] = "Unprotect";
    DFUWUActions2["Restore"] = "Restore";
    DFUWUActions2["SetToFailed"] = "SetToFailed";
    DFUWUActions2["Archive"] = "Archive";
  })(FileSpray2.DFUWUActions || (FileSpray2.DFUWUActions = {}));
})(FileSpray || (FileSpray = {}));
const _FileSprayServiceBase = class _FileSprayServiceBase extends Service {
  constructor(optsConnection) {
    super(optsConnection, "FileSpray", "1.26");
  }
  AbortDFUWorkunit(request) {
    return this._connection.send("AbortDFUWorkunit", request, "json", false, void 0, "AbortDFUWorkunitResponse");
  }
  Copy(request) {
    return this._connection.send("Copy", request, "json", false, void 0, "CopyResponse");
  }
  CreateDFUPublisherWorkunit(request) {
    return this._connection.send("CreateDFUPublisherWorkunit", request, "json", false, void 0, "CreateDFUPublisherWorkunitResponse");
  }
  CreateDFUWorkunit(request) {
    return this._connection.send("CreateDFUWorkunit", request, "json", false, void 0, "CreateDFUWorkunitResponse");
  }
  DFUWUFile(request) {
    return this._connection.send("DFUWUFile", request, "json", false, void 0, "DFUWUFileResponse");
  }
  DFUWUSearch(request) {
    return this._connection.send("DFUWUSearch", request, "json", false, void 0, "DFUWUSearchResponse");
  }
  DFUWorkunitsAction(request) {
    return this._connection.send("DFUWorkunitsAction", request, "json", false, void 0, "DFUWorkunitsActionResponse");
  }
  DeleteDFUWorkunit(request) {
    return this._connection.send("DeleteDFUWorkunit", request, "json", false, void 0, "DeleteDFUWorkunitResponse");
  }
  DeleteDFUWorkunits(request) {
    return this._connection.send("DeleteDFUWorkunits", request, "json", false, void 0, "DeleteDFUWorkunitsResponse");
  }
  DeleteDropZoneFiles(request) {
    return this._connection.send("DeleteDropZoneFiles", request, "json", false, void 0, "DFUWorkunitsActionResponse");
  }
  Despray(request) {
    return this._connection.send("Despray", request, "json", false, void 0, "DesprayResponse");
  }
  DfuMonitor(request) {
    return this._connection.send("DfuMonitor", request, "json", false, void 0, "DfuMonitorResponse");
  }
  DropZoneFileSearch(request) {
    return this._connection.send("DropZoneFileSearch", request, "json", false, void 0, "DropZoneFileSearchResponse");
  }
  DropZoneFiles(request) {
    return this._connection.send("DropZoneFiles", request, "json", false, void 0, "DropZoneFilesResponse");
  }
  EchoDateTime(request) {
    return this._connection.send("EchoDateTime", request, "json", false, void 0, "EchoDateTimeResponse");
  }
  FileList(request) {
    return this._connection.send("FileList", request, "json", false, void 0, "FileListResponse");
  }
  GetDFUExceptions(request) {
    return this._connection.send("GetDFUExceptions", request, "json", false, void 0, "GetDFUExceptionsResponse");
  }
  GetDFUProgress(request) {
    return this._connection.send("GetDFUProgress", request, "json", false, void 0, "ProgressResponse");
  }
  GetDFUServerQueues(request) {
    return this._connection.send("GetDFUServerQueues", request, "json", false, void 0, "GetDFUServerQueuesResponse");
  }
  GetDFUWorkunit(request) {
    return this._connection.send("GetDFUWorkunit", request, "json", false, void 0, "GetDFUWorkunitResponse");
  }
  GetDFUWorkunits(request) {
    return this._connection.send("GetDFUWorkunits", request, "json", false, void 0, "GetDFUWorkunitsResponse");
  }
  GetRemoteTargets(request) {
    return this._connection.send("GetRemoteTargets", request, "json", false, void 0, "GetRemoteTargetsResponse");
  }
  GetSprayTargets(request) {
    return this._connection.send("GetSprayTargets", request, "json", false, void 0, "GetSprayTargetsResponse");
  }
  OpenSave(request) {
    return this._connection.send("OpenSave", request, "json", false, void 0, "OpenSaveResponse");
  }
  Ping(request) {
    return this._connection.send("Ping", request, "json", false, void 0, "FileSprayPingResponse");
  }
  Rename(request) {
    return this._connection.send("Rename", request, "json", false, void 0, "RenameResponse");
  }
  Replicate(request) {
    return this._connection.send("Replicate", request, "json", false, void 0, "ReplicateResponse");
  }
  ShowResult(request) {
    return this._connection.send("ShowResult", request, "json", false, void 0, "ShowResultResponse");
  }
  SprayFixed(request) {
    return this._connection.send("SprayFixed", request, "json", false, void 0, "SprayFixedResponse");
  }
  SprayVariable(request) {
    return this._connection.send("SprayVariable", request, "json", false, void 0, "SprayResponse");
  }
  SubmitDFUWorkunit(request) {
    return this._connection.send("SubmitDFUWorkunit", request, "json", false, void 0, "SubmitDFUWorkunitResponse");
  }
  UpdateDFUWorkunit(request) {
    return this._connection.send("UpdateDFUWorkunit", request, "json", false, void 0, "UpdateDFUWorkunitResponse");
  }
};
__name(_FileSprayServiceBase, "FileSprayServiceBase");
let FileSprayServiceBase = _FileSprayServiceBase;
var FileSprayStates = /* @__PURE__ */ ((FileSprayStates2) => {
  FileSprayStates2[FileSprayStates2["unknown"] = 0] = "unknown";
  FileSprayStates2[FileSprayStates2["scheduled"] = 1] = "scheduled";
  FileSprayStates2[FileSprayStates2["queued"] = 2] = "queued";
  FileSprayStates2[FileSprayStates2["started"] = 3] = "started";
  FileSprayStates2[FileSprayStates2["aborted"] = 4] = "aborted";
  FileSprayStates2[FileSprayStates2["failed"] = 5] = "failed";
  FileSprayStates2[FileSprayStates2["finished"] = 6] = "finished";
  FileSprayStates2[FileSprayStates2["monitoring"] = 7] = "monitoring";
  FileSprayStates2[FileSprayStates2["aborting"] = 8] = "aborting";
  FileSprayStates2[FileSprayStates2["notfound"] = 999] = "notfound";
  return FileSprayStates2;
})(FileSprayStates || {});
const _FileSprayService = class _FileSprayService extends FileSprayServiceBase {
  DFUWUFileEx(request) {
    return this._connection.send("DFUWUFile", request, "text");
  }
  SprayFixedEx(request) {
    return this._connection.send("SprayFixed", request);
  }
  SprayVariableEx(request) {
    return this._connection.send("SprayVariable", request, "json", false, null, "SprayResponse");
  }
  DesprayEx(request) {
    return this._connection.send("Despray", request);
  }
  UpdateDFUWorkunitEx(request) {
    return this._connection.send("UpdateDFUWorkunit", request, "json", false, void 0, "UpdateDFUWorkunitResponse");
  }
};
__name(_FileSprayService, "FileSprayService");
let FileSprayService = _FileSprayService;
var WsAccess;
((WsAccess2) => {
  ((ViewMemberType2) => {
    ViewMemberType2["User"] = "User";
    ViewMemberType2["Group"] = "Group";
  })(WsAccess2.ViewMemberType || (WsAccess2.ViewMemberType = {}));
  ((UserSortBy2) => {
    UserSortBy2["username"] = "username";
    UserSortBy2["fullname"] = "fullname";
    UserSortBy2["passwordexpiration"] = "passwordexpiration";
    UserSortBy2["employeeID"] = "employeeID";
    UserSortBy2["employeeNumber"] = "employeeNumber";
  })(WsAccess2.UserSortBy || (WsAccess2.UserSortBy = {}));
  ((GroupSortBy2) => {
    GroupSortBy2["Name"] = "Name";
    GroupSortBy2["ManagedBy"] = "ManagedBy";
  })(WsAccess2.GroupSortBy || (WsAccess2.GroupSortBy = {}));
  ((AccountTypeReq2) => {
    AccountTypeReq2["Any"] = "Any";
    AccountTypeReq2["User"] = "User";
    AccountTypeReq2["Group"] = "Group";
  })(WsAccess2.AccountTypeReq || (WsAccess2.AccountTypeReq = {}));
  ((ResourcePermissionSortBy2) => {
    ResourcePermissionSortBy2["Name"] = "Name";
    ResourcePermissionSortBy2["Type"] = "Type";
  })(WsAccess2.ResourcePermissionSortBy || (WsAccess2.ResourcePermissionSortBy = {}));
  ((ResourceSortBy2) => {
    ResourceSortBy2["Name"] = "Name";
  })(WsAccess2.ResourceSortBy || (WsAccess2.ResourceSortBy = {}));
})(WsAccess || (WsAccess = {}));
const _AccessServiceBase = class _AccessServiceBase extends Service {
  constructor(optsConnection) {
    super(optsConnection, "ws_access", "1.17");
  }
  AccountPermissions(request) {
    return this._connection.send("AccountPermissions", request, "json", false, void 0, "AccountPermissionsResponse");
  }
  AccountPermissionsV2(request) {
    return this._connection.send("AccountPermissionsV2", request, "json", false, void 0, "AccountPermissionsV2Response");
  }
  AddUser(request) {
    return this._connection.send("AddUser", request, "json", false, void 0, "AddUserResponse");
  }
  AddView(request) {
    return this._connection.send("AddView", request, "json", false, void 0, "AddViewResponse");
  }
  AddViewColumn(request) {
    return this._connection.send("AddViewColumn", request, "json", false, void 0, "AddViewColumnResponse");
  }
  AddViewMember(request) {
    return this._connection.send("AddViewMember", request, "json", false, void 0, "AddViewMemberResponse");
  }
  ClearPermissionsCache(request) {
    return this._connection.send("ClearPermissionsCache", request, "json", false, void 0, "ClearPermissionsCacheResponse");
  }
  DeleteView(request) {
    return this._connection.send("DeleteView", request, "json", false, void 0, "DeleteViewResponse");
  }
  DeleteViewColumn(request) {
    return this._connection.send("DeleteViewColumn", request, "json", false, void 0, "DeleteViewColumnResponse");
  }
  DeleteViewMember(request) {
    return this._connection.send("DeleteViewMember", request, "json", false, void 0, "DeleteViewMemberResponse");
  }
  DisableScopeScans(request) {
    return this._connection.send("DisableScopeScans", request, "json", false, void 0, "DisableScopeScansResponse");
  }
  EnableScopeScans(request) {
    return this._connection.send("EnableScopeScans", request, "json", false, void 0, "EnableScopeScansResponse");
  }
  FilePermission(request) {
    return this._connection.send("FilePermission", request, "json", false, void 0, "FilePermissionResponse");
  }
  GroupAction(request) {
    return this._connection.send("GroupAction", request, "json", false, void 0, "GroupActionResponse");
  }
  GroupAdd(request) {
    return this._connection.send("GroupAdd", request, "json", false, void 0, "GroupAddResponse");
  }
  GroupEdit(request) {
    return this._connection.send("GroupEdit", request, "json", false, void 0, "GroupEditResponse");
  }
  GroupMemberEdit(request) {
    return this._connection.send("GroupMemberEdit", request, "json", false, void 0, "GroupMemberEditResponse");
  }
  GroupMemberEditInput(request) {
    return this._connection.send("GroupMemberEditInput", request, "json", false, void 0, "GroupMemberEditInputResponse");
  }
  GroupMemberQuery(request) {
    return this._connection.send("GroupMemberQuery", request, "json", false, void 0, "GroupMemberQueryResponse");
  }
  GroupQuery(request) {
    return this._connection.send("GroupQuery", request, "json", false, void 0, "GroupQueryResponse");
  }
  Groups(request) {
    return this._connection.send("Groups", request, "json", false, void 0, "GroupResponse");
  }
  PermissionAction(request) {
    return this._connection.send("PermissionAction", request, "json", false, void 0, "PermissionActionResponse");
  }
  Permissions(request) {
    return this._connection.send("Permissions", request, "json", false, void 0, "BasednsResponse");
  }
  PermissionsReset(request) {
    return this._connection.send("PermissionsReset", request, "json", false, void 0, "PermissionsResetResponse");
  }
  Ping(request) {
    return this._connection.send("Ping", request, "json", false, void 0, "ws_accessPingResponse");
  }
  QueryScopeScansEnabled(request) {
    return this._connection.send("QueryScopeScansEnabled", request, "json", false, void 0, "QueryScopeScansEnabledResponse");
  }
  QueryUserViewColumns(request) {
    return this._connection.send("QueryUserViewColumns", request, "json", false, void 0, "QueryUserViewColumnsResponse");
  }
  QueryViewColumns(request) {
    return this._connection.send("QueryViewColumns", request, "json", false, void 0, "QueryViewColumnsResponse");
  }
  QueryViewMembers(request) {
    return this._connection.send("QueryViewMembers", request, "json", false, void 0, "QueryViewMembersResponse");
  }
  QueryViews(request) {
    return this._connection.send("QueryViews", request, "json", false, void 0, "QueryViewsResponse");
  }
  ResourceAdd(request) {
    return this._connection.send("ResourceAdd", request, "json", false, void 0, "ResourceAddResponse");
  }
  ResourceDelete(request) {
    return this._connection.send("ResourceDelete", request, "json", false, void 0, "ResourceDeleteResponse");
  }
  ResourcePermissionQuery(request) {
    return this._connection.send("ResourcePermissionQuery", request, "json", false, void 0, "ResourcePermissionQueryResponse");
  }
  ResourcePermissions(request) {
    return this._connection.send("ResourcePermissions", request, "json", false, void 0, "ResourcePermissionsResponse");
  }
  ResourceQuery(request) {
    return this._connection.send("ResourceQuery", request, "json", false, void 0, "ResourceQueryResponse");
  }
  Resources(request) {
    return this._connection.send("Resources", request, "json", false, void 0, "ResourcesResponse");
  }
  UserAccountExport(request) {
    return this._connection.send("UserAccountExport", request, "json", false, void 0, "UserAccountExportResponse");
  }
  UserAction(request) {
    return this._connection.send("UserAction", request, "json", false, void 0, "UserActionResponse");
  }
  UserEdit(request) {
    return this._connection.send("UserEdit", request, "json", false, void 0, "UserEditResponse");
  }
  UserGroupEdit(request) {
    return this._connection.send("UserGroupEdit", request, "json", false, void 0, "UserGroupEditResponse");
  }
  UserGroupEditInput(request) {
    return this._connection.send("UserGroupEditInput", request, "json", false, void 0, "UserGroupEditInputResponse");
  }
  UserInfoEdit(request) {
    return this._connection.send("UserInfoEdit", request, "json", false, void 0, "UserInfoEditResponse");
  }
  UserInfoEditInput(request) {
    return this._connection.send("UserInfoEditInput", request, "json", false, void 0, "UserInfoEditInputResponse");
  }
  UserPosix(request) {
    return this._connection.send("UserPosix", request, "json", false, void 0, "UserPosixResponse");
  }
  UserPosixInput(request) {
    return this._connection.send("UserPosixInput", request, "json", false, void 0, "UserPosixInputResponse");
  }
  UserQuery(request) {
    return this._connection.send("UserQuery", request, "json", false, void 0, "UserQueryResponse");
  }
  UserResetPass(request) {
    return this._connection.send("UserResetPass", request, "json", false, void 0, "UserResetPassResponse");
  }
  UserResetPassInput(request) {
    return this._connection.send("UserResetPassInput", request, "json", false, void 0, "UserResetPassInputResponse");
  }
  UserSudoers(request) {
    return this._connection.send("UserSudoers", request, "json", false, void 0, "UserSudoersResponse");
  }
  UserSudoersInput(request) {
    return this._connection.send("UserSudoersInput", request, "json", false, void 0, "UserSudoersInputResponse");
  }
  Users(request) {
    return this._connection.send("Users", request, "json", false, void 0, "UserResponse");
  }
};
__name(_AccessServiceBase, "AccessServiceBase");
let AccessServiceBase = _AccessServiceBase;
const _AccessService = class _AccessService extends AccessServiceBase {
};
__name(_AccessService, "AccessService");
let AccessService = _AccessService;
const _AccountServiceBase = class _AccountServiceBase extends Service {
  constructor(optsConnection) {
    super(optsConnection, "ws_account", "1.07");
  }
  MyAccount(request) {
    return this._connection.send("MyAccount", request, "json", false, void 0, "MyAccountResponse");
  }
  Ping(request) {
    return this._connection.send("Ping", request, "json", false, void 0, "ws_accountPingResponse");
  }
  UpdateUser(request) {
    return this._connection.send("UpdateUser", request, "json", false, void 0, "UpdateUserResponse");
  }
  UpdateUserInput(request) {
    return this._connection.send("UpdateUserInput", request, "json", false, void 0, "UpdateUserInputResponse");
  }
  VerifyUser(request) {
    return this._connection.send("VerifyUser", request, "json", false, void 0, "VerifyUserResponse");
  }
};
__name(_AccountServiceBase, "AccountServiceBase");
let AccountServiceBase = _AccountServiceBase;
const _AccountService = class _AccountService extends AccountServiceBase {
  VerifyUser(request) {
    return this._connection.send("VerifyUser", request).catch((e) => {
      if (e.isESPExceptions && e.Exception.some((exception) => exception.Code === 20043)) {
        return {
          retcode: 20043,
          Exceptions: {
            Source: "wsAccount",
            Exception: e.Exception
          }
        };
      }
      throw e;
    });
  }
};
__name(_AccountService, "AccountService");
let AccountService = _AccountService;
const _CloudServiceBase = class _CloudServiceBase extends Service {
  constructor(optsConnection) {
    super(optsConnection, "WsCloud", "1.02");
  }
  GetPODs(request) {
    return this._connection.send("GetPODs", request, "json", false, void 0, "GetPODsResponse");
  }
  GetServices(request) {
    return this._connection.send("GetServices", request, "json", false, void 0, "GetServicesResponse");
  }
  Ping(request) {
    return this._connection.send("Ping", request, "json", false, void 0, "WsCloudPingResponse");
  }
};
__name(_CloudServiceBase, "CloudServiceBase");
let CloudServiceBase = _CloudServiceBase;
const logger$5 = scopedLogger("@hpcc-js/comms/services/wsCloud.ts");
function isGetPODsResponse_v1_02(response) {
  return (response == null ? void 0 : response.Pods) !== void 0;
}
__name(isGetPODsResponse_v1_02, "isGetPODsResponse_v1_02");
function mapPorts(pod) {
  var _a, _b;
  return ((_b = (_a = pod.spec) == null ? void 0 : _a.containers) == null ? void 0 : _b.reduce((prev, curr) => {
    var _a2;
    (_a2 = curr.ports) == null ? void 0 : _a2.forEach((p) => {
      prev.push({
        ContainerPort: p.containerPort,
        Name: p.name,
        Protocol: p.protocol
      });
    });
    return prev;
  }, [])) ?? [];
}
__name(mapPorts, "mapPorts");
function mapPods(pods) {
  return pods.filter((pod) => {
    var _a;
    const labels = ((_a = pod == null ? void 0 : pod.metadata) == null ? void 0 : _a.labels) ?? {};
    return labels.hasOwnProperty("app.kubernetes.io/part-of") && labels["app.kubernetes.io/part-of"] === "HPCC-Platform";
  }).map((pod) => {
    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
    const started = new Date((_a = pod.metadata) == null ? void 0 : _a.creationTimestamp);
    return {
      Name: pod.metadata.name,
      Status: (_b = pod.status) == null ? void 0 : _b.phase,
      CreationTimestamp: started.toISOString(),
      ContainerName: ((_d = (_c = pod.status) == null ? void 0 : _c.containerStatuses) == null ? void 0 : _d.reduce((prev, curr) => {
        if (curr.name) {
          prev.push(curr.name);
        }
        return prev;
      }, []).join(", ")) ?? "",
      ContainerCount: ((_f = (_e = pod.spec) == null ? void 0 : _e.containers) == null ? void 0 : _f.length) ?? 0,
      ContainerReadyCount: (_h = (_g = pod.status) == null ? void 0 : _g.containerStatuses) == null ? void 0 : _h.reduce((prev, curr) => prev + (curr.ready ? 1 : 0), 0),
      ContainerRestartCount: (_j = (_i = pod.status) == null ? void 0 : _i.containerStatuses) == null ? void 0 : _j.reduce((prev, curr) => prev + curr.restartCount, 0),
      Ports: {
        Port: mapPorts(pod)
      }
    };
  });
}
__name(mapPods, "mapPods");
const _CloudService = class _CloudService extends CloudServiceBase {
  getPODs() {
    return super.GetPODs({}).then((response) => {
      var _a;
      if (isGetPODsResponse_v1_02(response)) {
        return ((_a = response.Pods) == null ? void 0 : _a.Pod) ?? [];
      }
      try {
        const obj = typeof response.Result === "string" ? JSON.parse(response.Result) : response.Result;
        return mapPods((obj == null ? void 0 : obj.items) ?? []);
      } catch (error) {
        logger$5.error(`Error parsing V1Pods json '${error instanceof Error ? error.message : String(error)}'`);
        return [];
      }
    });
  }
};
__name(_CloudService, "CloudService");
let CloudService = _CloudService;
const _CodesignService = class _CodesignService {
  constructor(optsConnection) {
    __publicField(this, "_connection");
    this._connection = new ESPConnection(optsConnection, "ws_codesign", "1.1");
  }
  connectionOptions() {
    return this._connection.opts();
  }
  ListUserIDs(request) {
    return this._connection.send("ListUserIDs", request).then((response) => {
      return response.UserIDs.Item;
    }).catch((e) => {
      return [];
    });
  }
  Sign(request) {
    return this._connection.send("Sign", { SigningMethod: "gpg", ...request });
  }
  Verify(request) {
    return this._connection.send("Verify", request);
  }
};
__name(_CodesignService, "CodesignService");
let CodesignService = _CodesignService;
const _DaliServiceBase = class _DaliServiceBase extends Service {
  constructor(optsConnection) {
    super(optsConnection, "WSDali", "1.07");
  }
  Add(request) {
    return this._connection.send("Add", request, "json", false, void 0, "ResultResponse");
  }
  ClearTraceTransactions(request) {
    return this._connection.send("ClearTraceTransactions", request, "json", false, void 0, "ResultResponse");
  }
  Count(request) {
    return this._connection.send("Count", request, "json", false, void 0, "CountResponse");
  }
  DFSCheck(request) {
    return this._connection.send("DFSCheck", request, "json", false, void 0, "ResultResponse");
  }
  DFSExists(request) {
    return this._connection.send("DFSExists", request, "json", false, void 0, "BooleanResponse");
  }
  DFSLS(request) {
    return this._connection.send("DFSLS", request, "json", false, void 0, "ResultResponse");
  }
  Delete(request) {
    return this._connection.send("Delete", request, "json", false, void 0, "ResultResponse");
  }
  DisconnectClientConnection(request) {
    return this._connection.send("DisconnectClientConnection", request, "json", false, void 0, "ResultResponse");
  }
  GetClients(request) {
    return this._connection.send("GetClients", request, "json", false, void 0, "ResultResponse");
  }
  GetConnections(request) {
    return this._connection.send("GetConnections", request, "json", false, void 0, "ResultResponse");
  }
  GetDFSCSV(request) {
    return this._connection.send("GetDFSCSV", request, "json", false, void 0, "ResultResponse");
  }
  GetDFSMap(request) {
    return this._connection.send("GetDFSMap", request, "json", false, void 0, "ResultResponse");
  }
  GetDFSParents(request) {
    return this._connection.send("GetDFSParents", request, "json", false, void 0, "ResultResponse");
  }
  GetLogicalFile(request) {
    return this._connection.send("GetLogicalFile", request, "json", false, void 0, "ResultResponse");
  }
  GetLogicalFilePart(request) {
    return this._connection.send("GetLogicalFilePart", request, "json", false, void 0, "ResultResponse");
  }
  GetProtectedList(request) {
    return this._connection.send("GetProtectedList", request, "json", false, void 0, "ResultResponse");
  }
  GetSDSStats(request) {
    return this._connection.send("GetSDSStats", request, "json", false, void 0, "ResultResponse");
  }
  GetSDSSubscribers(request) {
    return this._connection.send("GetSDSSubscribers", request, "json", false, void 0, "ResultResponse");
  }
  GetValue(request) {
    return this._connection.send("GetValue", request, "json", false, void 0, "ResultResponse");
  }
  Import(request) {
    return this._connection.send("Import", request, "json", false, void 0, "ResultResponse");
  }
  ListSDSLocks(request) {
    return this._connection.send("ListSDSLocks", request, "json", false, void 0, "ResultResponse");
  }
  Ping(request) {
    return this._connection.send("Ping", request, "json", false, void 0, "WSDaliPingResponse");
  }
  SaveSDSStore(request) {
    return this._connection.send("SaveSDSStore", request, "json", false, void 0, "ResultResponse");
  }
  SetLogicalFilePartAttr(request) {
    return this._connection.send("SetLogicalFilePartAttr", request, "json", false, void 0, "ResultResponse");
  }
  SetProtected(request) {
    return this._connection.send("SetProtected", request, "json", false, void 0, "ResultResponse");
  }
  SetTraceSlowTransactions(request) {
    return this._connection.send("SetTraceSlowTransactions", request, "json", false, void 0, "ResultResponse");
  }
  SetTraceTransactions(request) {
    return this._connection.send("SetTraceTransactions", request, "json", false, void 0, "ResultResponse");
  }
  SetUnprotected(request) {
    return this._connection.send("SetUnprotected", request, "json", false, void 0, "ResultResponse");
  }
  SetValue(request) {
    return this._connection.send("SetValue", request, "json", false, void 0, "ResultResponse");
  }
  UnlockSDSLock(request) {
    return this._connection.send("UnlockSDSLock", request, "json", false, void 0, "ResultResponse");
  }
};
__name(_DaliServiceBase, "DaliServiceBase");
let DaliServiceBase = _DaliServiceBase;
const _DaliService = class _DaliService extends DaliServiceBase {
};
__name(_DaliService, "DaliService");
let DaliService = _DaliService;
var WsDfu;
((WsDfu2) => {
  ((DFUArrayActions2) => {
    DFUArrayActions2["Delete"] = "Delete";
    DFUArrayActions2["AddToSuperfile"] = "Add To Superfile";
    DFUArrayActions2["ChangeProtection"] = "Change Protection";
    DFUArrayActions2["ChangeRestriction"] = "Change Restriction";
  })(WsDfu2.DFUArrayActions || (WsDfu2.DFUArrayActions = {}));
  ((DFUChangeProtection2) => {
    DFUChangeProtection2[DFUChangeProtection2["NoChange"] = 0] = "NoChange";
    DFUChangeProtection2[DFUChangeProtection2["Protect"] = 1] = "Protect";
    DFUChangeProtection2[DFUChangeProtection2["Unprotect"] = 2] = "Unprotect";
    DFUChangeProtection2[DFUChangeProtection2["UnprotectAll"] = 3] = "UnprotectAll";
  })(WsDfu2.DFUChangeProtection || (WsDfu2.DFUChangeProtection = {}));
  ((DFUChangeRestriction2) => {
    DFUChangeRestriction2[DFUChangeRestriction2["NoChange"] = 0] = "NoChange";
    DFUChangeRestriction2[DFUChangeRestriction2["Restrict"] = 1] = "Restrict";
    DFUChangeRestriction2[DFUChangeRestriction2["Unrestricted"] = 2] = "Unrestricted";
  })(WsDfu2.DFUChangeRestriction || (WsDfu2.DFUChangeRestriction = {}));
  ((DFUDefFileFormat2) => {
    DFUDefFileFormat2["xml"] = "xml";
    DFUDefFileFormat2["def"] = "def";
  })(WsDfu2.DFUDefFileFormat || (WsDfu2.DFUDefFileFormat = {}));
  ((FileAccessRole2) => {
    FileAccessRole2["Token"] = "Token";
    FileAccessRole2["Engine"] = "Engine";
    FileAccessRole2["External"] = "External";
  })(WsDfu2.FileAccessRole || (WsDfu2.FileAccessRole = {}));
  ((SecAccessType2) => {
    SecAccessType2["None"] = "None";
    SecAccessType2["Access"] = "Access";
    SecAccessType2["Read"] = "Read";
    SecAccessType2["Write"] = "Write";
    SecAccessType2["Full"] = "Full";
  })(WsDfu2.SecAccessType || (WsDfu2.SecAccessType = {}));
  ((DFUFileType2) => {
    DFUFileType2["Flat"] = "Flat";
    DFUFileType2["Index"] = "Index";
    DFUFileType2["Xml"] = "Xml";
    DFUFileType2["Csv"] = "Csv";
    DFUFileType2["Json"] = "Json";
    DFUFileType2["IndexLocal"] = "IndexLocal";
    DFUFileType2["IndexPartitioned"] = "IndexPartitioned";
    DFUFileType2["Unset"] = "Unset";
  })(WsDfu2.DFUFileType || (WsDfu2.DFUFileType = {}));
})(WsDfu || (WsDfu = {}));
const _DfuServiceBase = class _DfuServiceBase extends Service {
  constructor(optsConnection) {
    super(optsConnection, "WsDfu", "1.65");
  }
  Add(request) {
    return this._connection.send("Add", request, "json", false, void 0, "AddResponse");
  }
  AddRemote(request) {
    return this._connection.send("AddRemote", request, "json", false, void 0, "AddRemoteResponse");
  }
  AddtoSuperfile(request) {
    return this._connection.send("AddtoSuperfile", request, "json", false, void 0, "AddtoSuperfileResponse");
  }
  DFUArrayAction(request) {
    return this._connection.send("DFUArrayAction", request, "json", false, void 0, "DFUArrayActionResponse");
  }
  DFUBrowseData(request) {
    return this._connection.send("DFUBrowseData", request, "json", false, void 0, "DFUBrowseDataResponse");
  }
  DFUDefFile(request) {
    return this._connection.send("DFUDefFile", request, "json", false, void 0, "DFUDefFileResponse");
  }
  DFUFileAccess(request) {
    return this._connection.send("DFUFileAccess", request, "json", false, void 0, "DFUFileAccessResponse");
  }
  DFUFileAccessV2(request) {
    return this._connection.send("DFUFileAccessV2", request, "json", false, void 0, "DFUFileAccessResponse");
  }
  DFUFileCreate(request) {
    return this._connection.send("DFUFileCreate", request, "json", false, void 0, "DFUFileCreateResponse");
  }
  DFUFileCreateV2(request) {
    return this._connection.send("DFUFileCreateV2", request, "json", false, void 0, "DFUFileCreateResponse");
  }
  DFUFilePublish(request) {
    return this._connection.send("DFUFilePublish", request, "json", false, void 0, "DFUFilePublishResponse");
  }
  DFUFileView(request) {
    return this._connection.send("DFUFileView", request, "json", false, void 0, "DFUFileViewResponse");
  }
  DFUGetDataColumns(request) {
    return this._connection.send("DFUGetDataColumns", request, "json", false, void 0, "DFUGetDataColumnsResponse");
  }
  DFUGetFileMetaData(request) {
    return this._connection.send("DFUGetFileMetaData", request, "json", false, void 0, "DFUGetFileMetaDataResponse");
  }
  DFUInfo(request) {
    return this._connection.send("DFUInfo", request, "json", false, void 0, "DFUInfoResponse");
  }
  DFUQuery(request) {
    return this._connection.send("DFUQuery", request, "json", false, void 0, "DFUQueryResponse");
  }
  DFURecordTypeInfo(request) {
    return this._connection.send("DFURecordTypeInfo", request, "json", false, void 0, "DFURecordTypeInfoResponse");
  }
  DFUSearch(request) {
    return this._connection.send("DFUSearch", request, "json", false, void 0, "DFUSearchResponse");
  }
  DFUSearchData(request) {
    return this._connection.send("DFUSearchData", request, "json", false, void 0, "DFUSearchDataResponse");
  }
  DFUSpace(request) {
    return this._connection.send("DFUSpace", request, "json", false, void 0, "DFUSpaceResponse");
  }
  EclRecordTypeInfo(request) {
    return this._connection.send("EclRecordTypeInfo", request, "json", false, void 0, "EclRecordTypeInfoResponse");
  }
  EraseHistory(request) {
    return this._connection.send("EraseHistory", request, "json", false, void 0, "EraseHistoryResponse");
  }
  ListHistory(request) {
    return this._connection.send("ListHistory", request, "json", false, void 0, "ListHistoryResponse");
  }
  Ping(request) {
    return this._connection.send("Ping", request, "json", false, void 0, "WsDfuPingResponse");
  }
  Savexml(request) {
    return this._connection.send("Savexml", request, "json", false, void 0, "SavexmlResponse");
  }
  SuperfileAction(request) {
    return this._connection.send("SuperfileAction", request, "json", false, void 0, "SuperfileActionResponse");
  }
  SuperfileList(request) {
    return this._connection.send("SuperfileList", request, "json", false, void 0, "SuperfileListResponse");
  }
};
__name(_DfuServiceBase, "DfuServiceBase");
let DfuServiceBase = _DfuServiceBase;
const DFUArrayActions = WsDfu.DFUArrayActions;
const DFUDefFileFormat = WsDfu.DFUDefFileFormat;
const DFUChangeProtection = WsDfu.DFUChangeProtection;
const DFUChangeRestriction = WsDfu.DFUChangeRestriction;
const _DFUService = class _DFUService extends DfuServiceBase {
  DFUFile(request) {
    return this._connection.send("DFUDefFile", request, "text");
  }
  async recursiveFetchLogicalFiles(superFiles) {
    const childSuperFiles = [];
    const logicalFiles = [];
    await Promise.all(superFiles.map((superFile) => {
      return this.DFUInfo({ Cluster: superFile.NodeGroup, Name: superFile.Name, IncludeJsonTypeInfo: false, IncludeBinTypeInfo: false, ForceIndexInfo: false }).then((response) => {
        var _a, _b, _c, _d;
        for (const child of ((_b = (_a = response == null ? void 0 : response.FileDetail) == null ? void 0 : _a.Superfiles) == null ? void 0 : _b.DFULogicalFile) ?? []) {
          childSuperFiles.push(child);
        }
        for (const child of ((_d = (_c = response == null ? void 0 : response.FileDetail) == null ? void 0 : _c.subfiles) == null ? void 0 : _d.Item) ?? []) {
          logicalFiles.push(child);
        }
      });
    }));
    return logicalFiles.concat(childSuperFiles.length ? await this.recursiveFetchLogicalFiles(childSuperFiles) : []);
  }
};
__name(_DFUService, "DFUService");
let DFUService = _DFUService;
const _DFUXRefService = class _DFUXRefService extends Service {
  constructor(optsConnection) {
    super(optsConnection, "WsDFUXRef", "1.01");
  }
  DFUXRefArrayAction(request) {
    return this._connection.send("DFUXRefArrayAction", request);
  }
  DFUXRefBuild(request) {
    return this._connection.send("DFUXRefBuild", request);
  }
  DFUXRefBuildCancel(request) {
    return this._connection.send("DFUXRefBuildCancel", request);
  }
  DFUXRefCleanDirectories(request) {
    return this._connection.send("DFUXRefCleanDirectories", request);
  }
  DFUXRefDirectories(request) {
    return this._connection.send("DFUXRefDirectories", request, void 0, void 0, void 0, "DFUXRefDirectoriesQueryResponse");
  }
  DFUXRefFoundFiles(request) {
    return this._connection.send("DFUXRefFoundFiles", request, void 0, void 0, void 0, "DFUXRefFoundFilesQueryResponse");
  }
  DFUXRefList(request = {}) {
    return this._connection.send("DFUXRefList", request);
  }
  DFUXRefLostFiles(request) {
    return this._connection.send("DFUXRefLostFiles", request, void 0, void 0, void 0, "DFUXRefLostFilesQueryResponse");
  }
  DFUXRefMessages(request) {
    return this._connection.send("DFUXRefMessages", request, void 0, void 0, void 0, "DFUXRefMessagesQueryResponse");
  }
  DFUXRefOrphanFiles(request) {
    return this._connection.send("DFUXRefOrphanFiles", request, void 0, void 0, void 0, "DFUXRefOrphanFilesQueryResponse");
  }
  DFUXRefUnusedFiles(request) {
    return this._connection.send("DFUXRefUnusedFiles", request);
  }
};
__name(_DFUXRefService, "DFUXRefService");
let DFUXRefService = _DFUXRefService;
function jsonToIField(id, item) {
  const type = typeof item;
  switch (type) {
    case "boolean":
    case "number":
    case "string":
      return { id, type };
    case "object":
      if (item.Row instanceof Array) {
        item = item.Row;
      }
      if (item instanceof Array) {
        return {
          id,
          type: "dataset",
          children: jsonToIFieldArr(item[0])
        };
      } else if (item instanceof Object) {
        if (item.Item && item.Item instanceof Array && item.Item.length === 1) {
          const fieldType = typeof item.Item[0];
          if (fieldType === "string" || fieldType === "number") {
            return {
              id,
              type: "set",
              fieldType
            };
          }
          throw new Error("Unknown field type");
        }
        return {
          id,
          type: "object",
          fields: jsonToIFieldObj(item)
        };
      }
    default:
      throw new Error("Unknown field type");
  }
}
__name(jsonToIField, "jsonToIField");
function jsonToIFieldArr(json) {
  if (json.Row && json.Row instanceof Array) {
    json = json.Row[0];
  }
  const retVal = [];
  for (const key in json) {
    retVal.push(jsonToIField(key, json[key]));
  }
  return retVal;
}
__name(jsonToIFieldArr, "jsonToIFieldArr");
function jsonToIFieldObj(json) {
  const fields = {};
  for (const key in json) {
    fields[key] = jsonToIField(key, json[key]);
  }
  return fields;
}
__name(jsonToIFieldObj, "jsonToIFieldObj");
const _EclService = class _EclService extends Service {
  constructor(optsConnection) {
    super(optsConnection, "WsEcl", "0");
  }
  opts() {
    return this._connection.opts();
  }
  requestJson(querySet, queryId) {
    return this._connection.send(`example/request/query/${querySet}/${queryId}/json`, {}, "text").then((response) => {
      const requestSchema = JSON.parse(response);
      for (const key in requestSchema) {
        return requestSchema[key];
      }
      return {};
    }).then(jsonToIFieldArr);
  }
  responseJson(querySet, queryId) {
    return t