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

import { scopedLogger, join, promiseTimeout, exists, deepMixin, xml2json, StateObject, Cache, Graph, Subgraph, Vertex, Edge, SAXStackParser, Stack, espTime2Seconds, deepMixinT, XMLNode, debounce, Message, Dispatch, find, Dictionary, DictionaryNoCase, root } from '@hpcc-js/util';
import { DOMParser } from 'xmldom';
import fetch$1 from 'node-fetch';
import { Buffer } from 'safe-buffer';
import { spawn } from 'child_process';
import { readdirSync, lstatSync, existsSync, accessSync, readFileSync, unlink, statSync } from 'fs';
import { type, EOL } from 'os';
import { join as join$1, basename, extname, parse, relative, sep, dirname, normalize } from 'path';
import { tmpNameSync } from 'tmp';

var PKG_NAME = "@hpcc-js/comms";
var PKG_VERSION = "2.17.0";
var BUILD_VERSION = "2.20.0";

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */

var extendStatics = function(d, b) {
    extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return extendStatics(d, b);
};

function __extends(d, b) {
    extendStatics(d, b);
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};

function __awaiter(thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function __generator(thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
}

function __spreadArrays() {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
}

var logger = scopedLogger("comms/connection.ts");
function instanceOfIOptions(object) {
    return "baseUrl" in object;
}
var 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";
}
//  comms  ---
function encode(uriComponent, encodeRequest) {
    return (encodeRequest === undefined || encodeRequest === true) ? encodeURIComponent(uriComponent) : "" + uriComponent;
}
function serializeRequest(obj, encodeRequest, prefix) {
    if (encodeRequest === void 0) { encodeRequest = true; }
    if (prefix === void 0) { prefix = ""; }
    if (prefix) {
        prefix += ".";
    }
    if (typeof obj !== "object") {
        return encode(obj, encodeRequest);
    }
    var str = [];
    var _loop_1 = function (key) {
        if (obj.hasOwnProperty(key)) {
            if (obj[key] instanceof Array) {
                //  Specific to ESP - but no REST standard exists...
                var includeItemCount_1 = false;
                obj[key].forEach(function (row, i) {
                    if (typeof row === "object") {
                        includeItemCount_1 = 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_1) {
                    str.push(prefix + encode(key + ".itemcount", encodeRequest) + "=" + obj[key].length);
                }
            }
            else if (typeof obj[key] === "object") {
                if (obj[key] && obj[key]["Item"] instanceof Array) { // Specific to ws_machine.GetTargetClusterInfo?
                    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] !== undefined) {
                str.push(prefix + encode(key, encodeRequest) + "=" + encode(obj[key], encodeRequest));
            }
            else {
                str.push(prefix + encode(key, encodeRequest));
            }
        }
    };
    for (var key in obj) {
        _loop_1(key);
    }
    return str.join("&");
}
function deserializeResponse(body) {
    return JSON.parse(body);
}
function jsonp(opts, action, request, responseType, header) {
    if (request === void 0) { request = {}; }
    if (responseType === void 0) { responseType = "json"; }
    if (header) {
        console.warn("Header attributes ignored for JSONP connections");
    }
    return new Promise(function (resolve, reject) {
        var respondedTimeout = opts.timeoutSecs * 1000;
        var respondedTick = 5000;
        var callbackName = "jsonp_callback_" + Math.round(Math.random() * 999999);
        window[callbackName] = function (response) {
            respondedTimeout = 0;
            doCallback();
            resolve(responseType === "json" && typeof response === "string" ? deserializeResponse(response) : response);
        };
        var script = document.createElement("script");
        var url = join(opts.baseUrl, action);
        url += url.indexOf("?") >= 0 ? "&" : "?";
        script.src = url + "jsonp=" + callbackName + "&" + serializeRequest(request, opts.encodeRequest);
        document.body.appendChild(script);
        var progress = setInterval(function () {
            if (respondedTimeout <= 0) {
                clearInterval(progress);
            }
            else {
                respondedTimeout -= respondedTick;
                if (respondedTimeout <= 0) {
                    clearInterval(progress);
                    logger.error("Request timeout:  " + script.src);
                    doCallback();
                    reject(Error("Request timeout:  " + script.src));
                }
                else {
                    logger.debug("Request pending (" + respondedTimeout / 1000 + " sec):  " + script.src);
                }
            }
        }, respondedTick);
        function doCallback() {
            delete window[callbackName];
            document.body.removeChild(script);
        }
    });
}
function authHeader(opts) {
    return opts.userID ? { Authorization: "Basic " + btoa(opts.userID + ":" + opts.password) } : {};
}
//  _omitMap is a workaround for older HPCC-Platform instances without credentials ---
var _omitMap = {};
function doFetch(opts, action, requestInit, headersInit, responseType) {
    headersInit = __assign(__assign({}, authHeader(opts)), headersInit);
    requestInit = __assign(__assign({ credentials: _omitMap[opts.baseUrl] ? "omit" : "include" }, requestInit), { headers: headersInit });
    if (opts.rejectUnauthorized === false && fetch["__agent"] && opts.baseUrl.indexOf("https:") === 0) {
        //  NodeJS / node-fetch only  ---
        requestInit["agent"] = fetch["__agent"];
    }
    function handleResponse(response) {
        if (response.ok) {
            return responseType === "json" ? response.json() : response.text();
        }
        throw new Error(response.statusText);
    }
    return promiseTimeout(opts.timeoutSecs * 1000, fetch(join(opts.baseUrl, action), requestInit)
        .then(handleResponse)
        .catch(function (e) {
        //  Try again with the opposite credentials mode  ---
        requestInit.credentials = !_omitMap[opts.baseUrl] ? "omit" : "include";
        return fetch(join(opts.baseUrl, action), requestInit)
            .then(handleResponse)
            .then(function (responseBody) {
            _omitMap[opts.baseUrl] = !_omitMap[opts.baseUrl]; // The "opposite" credentials mode is known to work  ---
            return responseBody;
        });
    }));
}
function post(opts, action, request, responseType, header) {
    if (responseType === void 0) { responseType = "json"; }
    return doFetch(opts, action, {
        method: "post",
        body: serializeRequest(request, opts.encodeRequest)
    }, __assign({ "Content-Type": "application/x-www-form-urlencoded" }, header), responseType);
}
function get(opts, action, request, responseType, header) {
    if (responseType === void 0) { responseType = "json"; }
    return doFetch(opts, action + "?" + serializeRequest(request, opts.encodeRequest), {
        method: "get"
    }, __assign({}, header), responseType);
}
function send(opts, action, request, responseType, header) {
    if (responseType === void 0) { responseType = "json"; }
    var 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;
}
var hookedSend = send;
function hookSend(newSend) {
    var retVal = hookedSend;
    if (newSend) {
        hookedSend = newSend;
    }
    return retVal;
}
var Connection = /** @class */ (function () {
    function Connection(opts) {
        this.opts(opts);
    }
    Object.defineProperty(Connection.prototype, "baseUrl", {
        get: function () { return this._opts.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Connection.prototype.opts = function (_) {
        if (arguments.length === 0)
            return this._opts;
        this._opts = __assign(__assign({}, DefaultOptions), _);
        return this;
    };
    Connection.prototype.send = function (action, request, responseType, header) {
        if (responseType === void 0) { responseType = "json"; }
        if (this._opts.hookSend) {
            return this._opts.hookSend(this._opts, action, request, responseType, hookedSend, header);
        }
        return hookedSend(this._opts, action, request, responseType, header);
    };
    Connection.prototype.clone = function () {
        return new Connection(this.opts());
    };
    return Connection;
}());
var createConnection = function (opts) {
    return new Connection(opts);
};
function setTransportFactory(newFunc) {
    var retVal = createConnection;
    createConnection = newFunc;
    return retVal;
}

function isArray(arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
}
var ESPExceptions = /** @class */ (function (_super) {
    __extends(ESPExceptions, _super);
    function ESPExceptions(action, request, exceptions) {
        var _this = _super.call(this, "ESPException:  " + exceptions.Source) || this;
        _this.isESPExceptions = true;
        _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;
        }
        return _this;
    }
    return ESPExceptions;
}(Error));
function isConnection(optsConnection) {
    return optsConnection.send !== undefined;
}
var ESPConnection = /** @class */ (function () {
    function ESPConnection(optsConnection, service, version) {
        this._connection = isConnection(optsConnection) ? optsConnection : createConnection(optsConnection);
        this._service = service;
        this._version = version;
    }
    Object.defineProperty(ESPConnection.prototype, "baseUrl", {
        get: function () { return this._connection.opts().baseUrl; },
        enumerable: false,
        configurable: true
    });
    ESPConnection.prototype.service = function (_) {
        if (_ === void 0)
            return this._service;
        this._service = _;
        return this;
    };
    ESPConnection.prototype.version = function (_) {
        if (_ === void 0)
            return this._version;
        this._version = _;
        return this;
    };
    ESPConnection.prototype.toESPStringArray = function (target, arrayName) {
        if (isArray(target[arrayName])) {
            for (var i = 0; i < target[arrayName].length; ++i) {
                target[arrayName + "_i" + i] = target[arrayName][i];
            }
            delete target[arrayName];
        }
        return target;
    };
    ESPConnection.prototype.opts = function (_) {
        if (_ === void 0)
            return this._connection.opts();
        this._connection.opts(_);
        return this;
    };
    ESPConnection.prototype.send = function (action, _request, espResponseType, largeUpload) {
        if (_request === void 0) { _request = {}; }
        if (espResponseType === void 0) { espResponseType = "json"; }
        if (largeUpload === void 0) { largeUpload = false; }
        var request = __assign(__assign({}, _request), { ver_: this._version });
        if (largeUpload) {
            request["upload_"] = true;
        }
        var serviceAction;
        var 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";
                var actionParts = action.split("/");
                action = actionParts.pop();
                break;
            default:
                serviceAction = join(this._service, action + ".json");
        }
        return this._connection.send(serviceAction, request, responseType).then(function (response) {
            if (espResponseType === "json") {
                var retVal = void 0;
                if (response && response.Exceptions) {
                    throw new ESPExceptions(action, request, response.Exceptions);
                }
                else if (response) {
                    retVal = response[(action === "WUCDebug" ? "WUDebug" : action) + "Response"];
                }
                if (!retVal) {
                    throw new ESPExceptions(action, request, {
                        Source: "ESPConnection.send",
                        Exception: [{ Code: 0, Message: "Missing Response" }]
                    });
                }
                return retVal;
            }
            return response;
        }).catch(function (e) {
            if (e.isESPExceptions) {
                throw e;
            }
            throw new ESPExceptions(action, request, {
                Source: "ESPConnection.send",
                Exception: [{ Code: 0, Message: e.message }]
            });
        });
    };
    ESPConnection.prototype.clone = function () {
        return new ESPConnection(this._connection.clone(), this._service, this._version);
    };
    return ESPConnection;
}());
var Service = /** @class */ (function () {
    function Service(optsConnection, service, version) {
        this._connection = new ESPConnection(optsConnection, service, version);
    }
    Object.defineProperty(Service.prototype, "baseUrl", {
        get: function () { return this._connection.opts().baseUrl; },
        enumerable: false,
        configurable: true
    });
    return Service;
}());

var AccountService = /** @class */ (function () {
    function AccountService(optsConnection) {
        this._connection = new ESPConnection(optsConnection, "Ws_Account", "1.03");
    }
    AccountService.prototype.connectionOptions = function () {
        return this._connection.opts();
    };
    AccountService.prototype.VerifyUser = function (request) {
        return this._connection.send("VerifyUser", request);
    };
    return AccountService;
}());

var DFUService = /** @class */ (function (_super) {
    __extends(DFUService, _super);
    function DFUService(optsConnection) {
        return _super.call(this, optsConnection, "WsDfu", "1.5") || this;
    }
    DFUService.prototype.DFUQuery = function (request) {
        return this._connection.send("DFUQuery", request);
    };
    DFUService.prototype.DFUInfo = function (request) {
        return this._connection.send("DFUInfo", request);
    };
    return DFUService;
}(Service));

function jsonToIField(id, item) {
    var type = typeof item;
    switch (type) {
        case "boolean":
        case "number":
        case "string":
            return { id: id, type: type };
        case "object":
            if (item.Row instanceof Array) {
                item = item.Row;
            }
            if (item instanceof Array) {
                return {
                    id: id,
                    type: "dataset",
                    children: jsonToIFieldArr(item[0])
                };
            }
            else if (item instanceof Object) {
                if (item.Item && item.Item instanceof Array && item.Item.length === 1) {
                    var fieldType = typeof item.Item[0];
                    if (fieldType === "string" || fieldType === "number") {
                        return {
                            id: id,
                            type: "set",
                            fieldType: fieldType
                        };
                    }
                    throw new Error("Unknown field type");
                }
                return {
                    id: id,
                    type: "object",
                    fields: jsonToIFieldObj(item)
                };
            }
        // Fall through  ---
        default:
            throw new Error("Unknown field type");
    }
}
function jsonToIFieldArr(json) {
    if (json.Row && json.Row instanceof Array) {
        json = json.Row[0];
    }
    var retVal = [];
    for (var key in json) {
        retVal.push(jsonToIField(key, json[key]));
    }
    return retVal;
}
function jsonToIFieldObj(json) {
    var fields = {};
    for (var key in json) {
        fields[key] = jsonToIField(key, json[key]);
    }
    return fields;
}
var EclService = /** @class */ (function (_super) {
    __extends(EclService, _super);
    function EclService(optsConnection) {
        return _super.call(this, optsConnection, "WsEcl", "0") || this;
    }
    EclService.prototype.opts = function () {
        return this._connection.opts();
    };
    EclService.prototype.requestJson = function (querySet, queryId) {
        // http://192.168.3.22:8002/WsEcl/example/request/query/roxie/peopleaccounts/json?display
        return this._connection.send("example/request/query/" + querySet + "/" + queryId + "/json", {}, "text").then(function (response) {
            var requestSchema = JSON.parse(response);
            for (var key in requestSchema) {
                return requestSchema[key];
            }
            return {};
        }).then(jsonToIFieldArr);
    };
    EclService.prototype.responseJson = function (querySet, queryId) {
        // http://192.168.3.22:8002/WsEcl/example/response/query/roxie/peopleaccounts/json?display
        return this._connection.send("example/response/query/" + querySet + "/" + queryId + "/json", {}, "text").then(function (response) {
            var responseSchema = JSON.parse(response);
            for (var key in responseSchema) {
                return responseSchema[key].Results;
            }
            return {};
        }).then(function (resultsJson) {
            var retVal = {};
            for (var key in resultsJson) {
                retVal[key] = jsonToIFieldArr(resultsJson[key]);
            }
            return retVal;
        });
    };
    EclService.prototype.submit = function (querySet, queryId, request) {
        // http://192.168.3.22:8002/WsEcl/submit/query/roxie/peopleaccounts.1/json
        var action = "submit/query/" + querySet + "/" + queryId;
        return this._connection.send(action, request, "json2").then(function (response) {
            if (response.Results && response.Results.Exception) {
                throw new ESPExceptions(action, request, {
                    Source: "wsEcl.submit",
                    Exception: response.Results.Exception
                });
            }
            return response.Results;
        });
    };
    return EclService;
}(Service));

function ascending(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

function bisector(compare) {
  if (compare.length === 1) compare = ascendingComparator(compare);
  return {
    left: function(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      while (lo < hi) {
        var mid = lo + hi >>> 1;
        if (compare(a[mid], x) < 0) lo = mid + 1;
        else hi = mid;
      }
      return lo;
    },
    right: function(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      while (lo < hi) {
        var mid = lo + hi >>> 1;
        if (compare(a[mid], x) > 0) hi = mid;
        else lo = mid + 1;
      }
      return lo;
    }
  };
}

function ascendingComparator(f) {
  return function(d, x) {
    return ascending(f(d), x);
  };
}

var ascendingBisect = bisector(ascending);

function number(x) {
  return x === null ? NaN : +x;
}

function d3Max(values, valueof) {
  var n = values.length,
      i = -1,
      value,
      max;

  if (valueof == null) {
    while (++i < n) { // Find the first comparable value.
      if ((value = values[i]) != null && value >= value) {
        max = value;
        while (++i < n) { // Compare the remaining values.
          if ((value = values[i]) != null && value > max) {
            max = value;
          }
        }
      }
    }
  }

  else {
    while (++i < n) { // Find the first comparable value.
      if ((value = valueof(values[i], i, values)) != null && value >= value) {
        max = value;
        while (++i < n) { // Compare the remaining values.
          if ((value = valueof(values[i], i, values)) != null && value > max) {
            max = value;
          }
        }
      }
    }
  }

  return max;
}

function d3Mean(values, valueof) {
  var n = values.length,
      m = n,
      i = -1,
      value,
      sum = 0;

  if (valueof == null) {
    while (++i < n) {
      if (!isNaN(value = number(values[i]))) sum += value;
      else --m;
    }
  }

  else {
    while (++i < n) {
      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
      else --m;
    }
  }

  if (m) return sum / m;
}

var MachineService = /** @class */ (function () {
    function MachineService(optsConnection) {
        this._connection = new ESPConnection(optsConnection, "ws_machine", "1.13");
    }
    MachineService.prototype.GetTargetClusterInfo = function (request) {
        if (request === void 0) { request = {}; }
        return this._connection.send("GetTargetClusterInfo", request);
    };
    MachineService.prototype.GetTargetClusterUsage = function (targetClusters, bypassCachedResult) {
        if (bypassCachedResult === void 0) { bypassCachedResult = false; }
        return this._connection.send("GetTargetClusterUsage", {
            TargetClusters: targetClusters ? { Item: targetClusters } : {},
            BypassCachedResult: bypassCachedResult
        }).then(function (response) {
            return exists("TargetClusterUsages.TargetClusterUsage", response) ? response.TargetClusterUsages.TargetClusterUsage : [];
        });
    };
    MachineService.prototype.GetTargetClusterUsageEx = function (targetClusters, bypassCachedResult) {
        if (bypassCachedResult === void 0) { bypassCachedResult = false; }
        return this.GetTargetClusterUsage(targetClusters, bypassCachedResult).then(function (response) {
            return response.filter(function (tcu) { return !!tcu.ComponentUsages; }).map(function (tcu) {
                var ComponentUsages = tcu.ComponentUsages.ComponentUsage.map(function (cu) {
                    var MachineUsages = (cu.MachineUsages && cu.MachineUsages.MachineUsage ? cu.MachineUsages.MachineUsage : []).map(function (mu) {
                        var DiskUsages = mu.DiskUsages && mu.DiskUsages.DiskUsage ? mu.DiskUsages.DiskUsage.map(function (du) {
                            return __assign(__assign({}, du), { Total: du.InUse + du.Available, PercentUsed: 100 - du.PercentAvailable });
                        }) : [];
                        return {
                            Name: mu.Name,
                            NetAddress: mu.NetAddress,
                            Description: mu.Description,
                            DiskUsages: DiskUsages,
                            mean: d3Mean(DiskUsages.filter(function (du) { return !isNaN(du.PercentUsed); }), function (du) { return du.PercentUsed; }),
                            max: d3Max(DiskUsages.filter(function (du) { return !isNaN(du.PercentUsed); }), function (du) { return du.PercentUsed; })
                        };
                    });
                    return {
                        Type: cu.Type,
                        Name: cu.Name,
                        Description: cu.Description,
                        MachineUsages: MachineUsages,
                        MachineUsagesDescription: MachineUsages.reduce(function (prev, mu) { return prev + (mu.Description || ""); }, ""),
                        mean: d3Mean(MachineUsages.filter(function (mu) { return !isNaN(mu.mean); }), function (mu) { return mu.mean; }),
                        max: d3Max(MachineUsages.filter(function (mu) { return !isNaN(mu.max); }), function (mu) { return mu.max; })
                    };
                });
                return {
                    Name: tcu.Name,
                    Description: tcu.Description,
                    ComponentUsages: ComponentUsages,
                    ComponentUsagesDescription: ComponentUsages.reduce(function (prev, cu) { return prev + (cu.MachineUsagesDescription || ""); }, ""),
                    mean: d3Mean(ComponentUsages.filter(function (cu) { return !isNaN(cu.mean); }), function (cu) { return cu.mean; }),
                    max: d3Max(ComponentUsages.filter(function (cu) { return !isNaN(cu.max); }), function (cu) { return cu.max; })
                };
            });
        });
    };
    return MachineService;
}());

var SMCService = /** @class */ (function () {
    function SMCService(optsConnection) {
        this._connection = new ESPConnection(optsConnection, "WsSMC", "1.19");
    }
    SMCService.prototype.connectionOptions = function () {
        return this._connection.opts();
    };
    SMCService.prototype.Activity = function (request) {
        return this._connection.send("Activity", request).then(function (response) {
            return __assign({ Running: {
                    ActiveWorkunit: []
                } }, response);
        });
    };
    return SMCService;
}());

var StoreService = /** @class */ (function (_super) {
    __extends(StoreService, _super);
    function StoreService(optsConnection) {
        return _super.call(this, optsConnection, "WsStore", "1") || this;
    }
    StoreService.prototype.CreateStore = function (request) {
        return this._connection.send("Fetch", request);
    };
    StoreService.prototype.Delete = function (request) {
        return this._connection.send("Delete", request).catch(function (e) {
            if (e.isESPExceptions && e.Exception.some(function (e) { return e.Code === -1; })) {
                //  "Delete" item does not exist  ---
                return {
                    Exceptions: undefined,
                    Success: true
                };
            }
            throw e;
        });
    };
    StoreService.prototype.DeleteNamespace = function (request) {
        return this._connection.send("DeleteNamespace", request);
    };
    StoreService.prototype.Fetch = function (request) {
        return this._connection.send("Fetch", request).catch(function (e) {
            if (e.isESPExceptions && e.Exception.some(function (e) { return e.Code === -1; })) {
                //  "Fetch" item does not exist  ---
                return {
                    Exceptions: undefined,
                    Value: undefined
                };
            }
            throw e;
        });
    };
    StoreService.prototype.FetchAll = function (request) {
        return this._connection.send("FetchAll", request);
    };
    StoreService.prototype.FetchKeyMD = function (request) {
        return this._connection.send("FetchKeyMD", request);
    };
    StoreService.prototype.ListKeys = function (request) {
        return this._connection.send("ListKeys", request);
    };
    StoreService.prototype.ListNamespaces = function (request) {
        return this._connection.send("ListNamespaces", request);
    };
    StoreService.prototype.Set = function (request) {
        return this._connection.send("Set", request);
    };
    return StoreService;
}(Service));

var TopologyService = /** @class */ (function (_super) {
    __extends(TopologyService, _super);
    function TopologyService(optsConnection) {
        return _super.call(this, optsConnection, "WsTopology", "1.25") || this;
    }
    TopologyService.prototype.connectionOptions = function () {
        return this._connection.opts();
    };
    TopologyService.prototype.protocol = function () {
        var parts = this._connection.opts().baseUrl.split("//");
        return parts[0];
    };
    TopologyService.prototype.ip = function () {
        var parts = this._connection.opts().baseUrl.split("//");
        var parts2 = parts[1].split(":");
        return parts2[0];
    };
    TopologyService.prototype.TpLogicalClusterQuery = function (request) {
        if (request === void 0) { request = {}; }
        return this._connection.send("TpLogicalClusterQuery", request);
    };
    TopologyService.prototype.DefaultTpLogicalClusterQuery = function (request) {
        if (request === void 0) { request = {}; }
        return this.TpLogicalClusterQuery(request).then(function (response) {
            if (response.default) {
                return response.default;
            }
            var firstHThor;
            var first;
            response.TpLogicalClusters.TpLogicalCluster.some(function (item, idx) {
                if (idx === 0) {
                    first = item;
                }
                if (item.Type === "hthor") {
                    firstHThor = item;
                    return true;
                }
                return false;
            });
            return firstHThor || first;
        });
    };
    TopologyService.prototype.TpServiceQuery = function (request) {
        return this._connection.send("TpServiceQuery", request);
    };
    TopologyService.prototype.TpTargetClusterQuery = function (request) {
        return this._connection.send("TpTargetClusterQuery", request);
    };
    TopologyService.prototype.TpListTargetClusters = function (request) {
        return this._connection.send("TpListTargetClusters", request);
    };
    return TopologyService;
}(Service));

/*
    Response structures generated via:
    * http://192.168.3.22:8010/WsWorkunits/WUQuery?respjson_
    * http://json2ts.com/
*/
var WUStateID;
(function (WUStateID) {
    WUStateID[WUStateID["Unknown"] = 0] = "Unknown";
    WUStateID[WUStateID["Compiled"] = 1] = "Compiled";
    WUStateID[WUStateID["Running"] = 2] = "Running";
    WUStateID[WUStateID["Completed"] = 3] = "Completed";
    WUStateID[WUStateID["Failed"] = 4] = "Failed";
    WUStateID[WUStateID["Archived"] = 5] = "Archived";
    WUStateID[WUStateID["Aborting"] = 6] = "Aborting";
    WUStateID[WUStateID["Aborted"] = 7] = "Aborted";
    WUStateID[WUStateID["Blocked"] = 8] = "Blocked";
    WUStateID[WUStateID["Submitted"] = 9] = "Submitted";
    WUStateID[WUStateID["Scheduled"] = 10] = "Scheduled";
    WUStateID[WUStateID["Compiling"] = 11] = "Compiling";
    WUStateID[WUStateID["Wait"] = 12] = "Wait";
    WUStateID[WUStateID["UploadingFiled"] = 13] = "UploadingFiled";
    WUStateID[WUStateID["DebugPaused"] = 14] = "DebugPaused";
    WUStateID[WUStateID["DebugRunning"] = 15] = "DebugRunning";
    WUStateID[WUStateID["Paused"] = 16] = "Paused";
    WUStateID[WUStateID["LAST"] = 17] = "LAST";
    WUStateID[WUStateID["NotFound"] = 999] = "NotFound";
})(WUStateID || (WUStateID = {}));
var WUUpdate;
(function (WUUpdate) {
    var Action;
    (function (Action) {
        Action[Action["Unknown"] = 0] = "Unknown";
        Action[Action["Compile"] = 1] = "Compile";
        Action[Action["Check"] = 2] = "Check";
        Action[Action["Run"] = 3] = "Run";
        Action[Action["ExecuteExisting"] = 4] = "ExecuteExisting";
        Action[Action["Pause"] = 5] = "Pause";
        Action[Action["PauseNow"] = 6] = "PauseNow";
        Action[Action["Resume"] = 7] = "Resume";
        Action[Action["Debug"] = 8] = "Debug";
        Action[Action["__size"] = 9] = "__size";
    })(Action = WUUpdate.Action || (WUUpdate.Action = {}));
})(WUUpdate || (WUUpdate = {}));
function isWUQueryECLWorkunit(_) {
    return _.TotalClusterTime !== undefined;
}
function isWUInfoWorkunit(_) {
    return _.StateEx !== undefined;
}
var WorkunitsService = /** @class */ (function (_super) {
    __extends(WorkunitsService, _super);
    function WorkunitsService(optsConnection) {
        return _super.call(this, optsConnection, "WsWorkunits", "1.68") || this;
    }
    WorkunitsService.prototype.opts = function () {
        return this._connection.opts();
    };
    WorkunitsService.prototype.connection = function () {
        return this._connection;
    };
    WorkunitsService.prototype.WUQuery = function (request) {
        if (request === void 0) { request = {}; }
        return this._connection.send("WUQuery", request).then(function (response) {
            return deepMixin({ Workunits: { ECLWorkunit: [] } }, response);
        });
    };
    WorkunitsService.prototype.WUInfo = function (_request) {
        var request = __assign({ Wuid: "", TruncateEclTo64k: true, IncludeExceptions: false, IncludeGraphs: false, IncludeSourceFiles: false, IncludeResults: false, IncludeResultsViewNames: false, IncludeVariables: false, IncludeTimers: false, IncludeDebugValues: false, IncludeApplicationValues: false, IncludeWorkflows: false, IncludeXmlSchemas: false, IncludeResourceURLs: false, SuppressResultSchemas: true }, _request);
        return this._connection.send("WUInfo", request);
    };
    WorkunitsService.prototype.WUCreate = function () {
        return this._connection.send("WUCreate");
    };
    WorkunitsService.prototype.WUUpdate = function (request) {
        return this._connection.send("WUUpdate", request, "json", true);
    };
    WorkunitsService.prototype.WUSubmit = function (request) {
        return this._connection.send("WUSubmit", request);
    };
    WorkunitsService.prototype.WUResubmit = function (request) {
        this._connection.toESPStringArray(request, "Wuids");
        return this._connection.send("WUResubmit", request);
    };
    WorkunitsService.prototype.WUQueryDetails = function (request) {
        return this._connection.send("WUQueryDetails", request);
    };
    WorkunitsService.prototype.WUListQueries = function (request) {
        return this._connection.send("WUListQueries", request);
    };
    WorkunitsService.prototype.WUPushEvent = function (request) {
        return this._connection.send("WUPushEvent", request);
    };
    WorkunitsService.prototype.WUAction = function (request) {
        request.ActionType = request.WUActionType; //  v5.x compatibility
        return this._connection.send("WUAction", request);
    };
    WorkunitsService.prototype.WUGetZAPInfo = function (request) {
        return this._connection.send("WUGetZAPInfo", request);
    };
    WorkunitsService.prototype.WUShowScheduled = function (request) {
        return this._connection.send("WUShowScheduled", request);
    };
    WorkunitsService.prototype.WUQuerySetAliasAction = function (request) {
        return this._connection.send("WUQuerySetAliasAction", request);
    };
    WorkunitsService.prototype.WUQuerySetQueryAction = function (request) {
        return this._connection.send("WUQuerySetQueryAction", request);
    };
    WorkunitsService.prototype.WUPublishWorkunit = function (request) {
        return this._connection.send("WUPublishWorkunit", request);
    };
    WorkunitsService.prototype.WUGetGraph = function (request) {
        return this._connection.send("WUGetGraph", request);
    };
    WorkunitsService.prototype.WUResult = function (request) {
        return this._connection.send("WUResult", request);
    };
    WorkunitsService.prototype.WUQueryGetGraph = function (request) {
        return this._connection.send("WUQueryGetGraph", request);
    };
    WorkunitsService.prototype.WUFile = function (request) {
        return this._connection.send("WUFile", request, "text");
    };
    WorkunitsService.prototype.WUGetStats = function (request) {
        return this._connection.send("WUGetStats", request);
    };
    WorkunitsService.prototype.WUDetailsMeta = function (request) {
        if (!this._WUDetailsMetaPromise) {
            this._WUDetailsMetaPromise = this._connection.send("WUDetailsMeta", request);
        }
        return this._WUDetailsMetaPromise;
    };
    WorkunitsService.prototype.WUDetails = function (request) {
        return this._connection.send("WUDetails", request);
    };
    WorkunitsService.prototype.WUCDebug = function (request) {
        return this._connection.send("WUCDebug", request).then(function (response) {
            var retVal = xml2json(response.Result);
            var children = retVal.children();
            if (children.length) {
                return children[0];
            }
            return null;
        });
    };
    return WorkunitsService;
}(Service));

var t0 = new Date,
    t1 = new Date;

function newInterval(floori, offseti, count, field) {

  function interval(date) {
    return floori(date = new Date(+date)), date;
  }

  interval.floor = interval;

  interval.ceil = function(date) {
    return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
  };

  interval.round = function(date) {
    var d0 = interval(date),
        d1 = interval.ceil(date);
    return date - d0 < d1 - date ? d0 : d1;
  };

  interval.offset = function(date, step) {
    return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
  };

  interval.range = function(start, stop, step) {
    var range = [];
    start = interval.ceil(start);
    step = step == null ? 1 : Math.floor(step);
    if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
    do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)
    return range;
  };

  interval.filter = function(test) {
    return newInterval(function(date) {
      if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
    }, function(date, step) {
      if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty
    });
  };

  if (count) {
    interval.count = function(start, end) {
      t0.setTime(+start), t1.setTime(+end);
      floori(t0), floori(t1);
      return Math.floor(count(t0, t1));
    };

    interval.every = function(step) {
      step = Math.floor(step);
      return !isFinite(step) || !(step > 0) ? null
          : !(step > 1) ? interval
          : interval.filter(field
              ? function(d) { return field(d) % step === 0; }
              : function(d) { return interval.count(0, d) % step === 0; });
    };
  }

  return interval;
}

var millisecond = newInterval(function() {
  // noop
}, function(date, step) {
  date.setTime(+date + step);
}, function(start, end) {
  return end - start;
});

// An optimized implementation for this simple case.
millisecond.every = function(k) {
  k = Math.floor(k);
  if (!isFinite(k) || !(k > 0)) return null;
  if (!(k > 1)) return millisecond;
  return newInterval(function(date) {
    date.setTime(Math.floor(date / k) * k);
  }, function(date, step) {
    date.setTime(+date + step * k);
  }, function(start, end) {
    return (end - start) / k;
  });
};

var durationSecond = 1e3;
var durationMinute = 6e4;
var durationHour = 36e5;
var durationDay = 864e5;
var durationWeek = 6048e5;

var second = newInterval(function(date) {
  date.setTime(Math.floor(date / durationSecond) * durationSecond);
}, function(date, step) {
  date.setTime(+date + step * durationSecond);
}, function(start, end) {
  return (end - start) / durationSecond;
}, function(date) {
  return date.getUTCSeconds();
});

var minute = newInterval(function(date) {
  date.setTime(Math.floor(date / durationMinute) * durationMinute);
}, function(date, step) {
  date.setTime(+date + step * durationMinute);
}, function(start, end) {
  return (end - start) / durationMinute;
}, function(date) {
  return date.getMinutes();
});

var hour = newInterval(function(date) {
  var offset = date.getTimezoneOffset() * durationMinute % durationHour;
  if (offset < 0) offset += durationHour;
  date.setTime(Math.floor((+date - offset) / durationHour) * durationHour + offset);
}, function(date, step) {
  date.setTime(+date + step * durationHour);
}, function(start, end) {
  return (end - start) / durationHour;
}, function(date) {
  return date.getHours();
});

var day = newInterval(function(date) {
  date.setHours(0, 0, 0, 0);
}, function(date, step) {
  date.setDate(date.getDate() + step);
}, function(start, end) {
  return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay;
}, function(date) {
  return date.getDate() - 1;
});

function weekday(i) {
  return newInterval(function(date) {
    date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
    date.setHours(0, 0, 0, 0);
  }, function(date, step) {
    date.setDate(date.getDate() + step * 7);
  }, function(start, end) {
    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
  });
}

var sunday = weekday(0);
var monday = weekday(1);
var tuesday = weekday(2);
var wednesday = weekday(3);
var thursday = weekday(4);
var friday = weekday(5);
var saturday = weekday(6);

var month = newInterval(function(date) {
  date.setDate(1);
  date.setHours(0, 0, 0, 0);
}, function(date, step) {
  date.setMonth(date.getMonth() + step);
}, function(start, end) {
  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
}, function(date) {
  return date.getMonth();
});

var year = newInterval(function(date) {
  date.setMonth(0, 1);
  date.setHours(0, 0, 0, 0);
}, function(date, step) {
  date.setFullYear(date.getFullYear() + step);
}, function(start, end) {
  return end.getFullYear() - start.getFullYear();
}, function(date) {
  return date.getFullYear();
});

// An optimized implementation for this simple case.
year.every = function(k) {
  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {
    date.setFullYear(Math.floor(date.getFullYear() / k) * k);
    date.setMonth(0, 1);
    date.setHours(0, 0, 0, 0);
  }, function(date, step) {
    date.setFullYear(date.getFullYear() + step * k);
  });
};

var utcMinute = newInterval(function(date) {
  date.setUTCSeconds(0, 0);
}, function(date, step) {
  date.setTime(+date + step * durationMinute);
}, function(start, end) {
  return (end - start) / durationMinute;
}, function(date) {
  return date.getUTCMinutes();
});

var utcHour = newInterval(function(date) {
  date.setUTCMinutes(0, 0, 0);
}, function(date, step) {
  date.setTime(+date + step * durationHour);
}, function(start, end) {
  return (end - start) / durationHour;
}, function(date) {
  return date.getUTCHours();
});

var utcDay = newInterval(function(date) {
  date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
  date.setUTCDate(date.getUTCDate() + step);
}, function(start, end) {
  return (end - start) / durationDay;
}, function(date) {
  return date.getUTCDate() - 1;
});

function utcWeekday(i) {
  return newInterval(function(date) {
    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
    date.setUTCHours(0, 0, 0, 0);
  }, function(date, step) {
    date.setUTCDate(date.getUTCDate() + step * 7);
  }, function(start, end) {
    return (end - start) / durationWeek;
  });
}

var utcSunday = utcWeekday(0);
var utcMonday = utcWeekday(1);
var utcTuesday = utcWeekday(2);
var utcWednesday = utcWeekday(3);
var utcThursday = utcWeekday(4);
var utcFriday = utcWeekday(5);
var utcSaturday = utcWeekday(6);

var utcMonth = newInterval(function(date) {
  date.setUTCDate(1);
  date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
  date.setUTCMonth(date.getUTCMonth() + step);
}, function(start, end) {
  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
}, function(date) {
  return date.getUTCMonth();
});

var utcYear = newInterval(function(date) {
  date.setUTCMonth(0, 1);
  date.setUTCHours(0, 0, 0, 0);
}, function(date, step) {
  date.setUTCFullYear(date.getUTCFullYear() + step);
}, function(start, end) {
  return end.getUTCFullYear() - start.getUTCFullYear();
}, function(date) {
  return date.getUTCFullYear();
});

// An optimized implementation for this simple case.
utcYear.every = function(k) {
  return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) {
    date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);
    date.setUTCMonth(0, 1);
    date.setUTCHours(0, 0, 0, 0);
  }, function(date, step) {
    date.setUTCFullYear(date.getUTCFullYear() + step * k);
  });
};

function localDate(d) {
  if (0 <= d.y && d.y < 100) {
    var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
    date.setFullYear(d.y);
    return date;
  }
  return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
}

function utcDate(d) {
  if (0 <= d.y && d.y < 100) {
    var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
    date.setUTCFullYear(d.y);
    return date;
  }
  return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
}

function newYear(y) {
  return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};
}

function formatLocale(locale) {
  var locale_dateTime = locale.dateTime,
      locale_date = locale.date,
      locale_time = locale.time,
      locale_periods = locale.periods,
      locale_weekdays = locale.days,
      locale_shortWeekdays = locale.shortDays,
      locale_months = locale.months,
      locale_shortMonths = locale.shortMonths;

  var periodRe = formatRe(locale_periods),
      periodLookup = formatLookup(locale_periods),
      weekdayRe = formatRe(locale_weekdays),
      weekdayLookup = formatLookup(locale_weekdays),
      shortWeekdayRe = formatRe(locale_shortWeekdays),
      shortWeekdayLookup = formatLookup(locale_shortWeekdays),
      monthRe = formatRe(locale_months),
      monthLookup = formatLookup(locale_months),
      shortMonthRe = formatRe(locale_shortMonths),
      shortMonthLookup = formatLookup(locale_shortMonths);

  var formats = {
    "a": formatShortWeekday,
    "A": formatWeekday,
    "b": formatShortMonth,
    "B": formatMonth,
    "c": null,
    "d": formatDayOfMonth,
    "e": formatDayOfMonth,
    "f": formatMicroseconds,
    "H": formatHour24,
    "I": formatHour12,
    "j": formatDayOfYear,
    "L": formatMilliseconds,
    "m": formatMonthNumber,
    "M": formatMinutes,
    "p": formatPeriod,
    "Q": formatUnixTimestamp,
    "s": formatUnixTimestampSeconds,
    "S": formatSeconds,
    "u": formatWeekdayNumberMonday,
    "U": formatWeekNumberSunday,
    "V": formatWeekNumberISO,
    "w": formatWeekdayNumberSunday,
    "W": formatWeekNumberMonday,
    "x": null,
    "X": null,
    "y": formatYear,
    "Y": formatFullYear,
    "Z": formatZone,
    "%": formatLiteralPercent
  };

  var utcFormats = {
    "a": formatUTCShortWeekday,
    "A": formatUTCWeekday,
    "b": formatUTCShortMonth,
    "B": formatUTCMonth,
    "c": null,
    "d": formatUTCDayOfMonth,
    "e": formatUTCDayOfMonth,
    "f": formatUTCMicroseconds,
    "H": formatUTCHour24,
    "I": formatUTCHour12,
    "j": formatUTCDayOfYear,
    "L": formatUTCMilliseconds,
    "m": formatUTCMonthNumber,
    "M": formatUTCMinutes,
    "p": formatUTCPeriod,
    "Q": formatUnixTimestamp,
    "s": formatUnixTimestampSeconds,
    "S": formatUTCSeconds,
    "u": formatUTCWeekdayNumberMonday,
    "U": formatUTCWeekNumberSunday,
    "V": formatUTCWeekNumberISO,
    "w": formatUTCWeekdayNumberSunday,
    "W": formatUTCWeekNumberMonday,
    "x": null,
    "X": null,
    "y": formatUTCYear,
    "Y": formatUTCFullYear,
    "Z": formatUTCZone,
    "%": formatLiteralPercent
  };

  var parses = {
    "a": parseShortWeekday,
    "A": parseWeekday,
    "b": parseShortMonth,
    "B": parseMonth,
    "c": parseLocaleDateTime,
    "d": parseDayOfMonth,
    "e": parseDayOfMonth,
    "f": parseMicroseconds,
    "H": parseHour24,
    "I": parseHour24,
    "j": parseDayOfYear,
    "L": parseMilliseconds,
    "m": parseMonthNumber,
    "M": parseMinutes,
    "p": parsePeriod,
    "Q": parseUnixTimestamp,
    "s": parseUnixTimestampSeconds,
    "S": parseSeconds,
    "u": parseWeekdayNumberMonday,
    "U": parseWeekNumberSunday,
    "V": parseWeekNumberISO,
    "w": parseWeekdayNumberSunday,
    "W": parseWeekNumberMonday,
    "x": parseLocaleDate,
    "X": parseLocaleTime,
    "y": parseYear,
    "Y": parseFullYear,
    "Z": parseZone,
    "%": parseLiteralPercent
  };

  // These recursive directive definitions must be deferred.
  formats.x = newFormat(locale_date, formats);
  formats.X = newFormat(locale_time, formats);
  formats.c = newFormat(locale_dateTime, formats);
  utcFormats.x = newFormat(locale_date, utcFormats);
  utcFormats.X = newFormat(locale_time, utcFormats);
  utcFormats.c = newFormat(locale_dateTime, utcFormats);

  function newFormat(specifier, formats) {
    return function(date) {
      var string = [],
          i = -1,
          j = 0,
          n = specifier.length,
          c,
          pad,
          format;

      if (!(date instanceof Date)) date = new Date(+date);

      while (++i < n) {
        if (specifier.charCodeAt(i) === 37) {
          string.push(specifier.slice(j, i));
          if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
          else pad = c === "e" ? " " : "0";
          if (format = formats[c]) c = format(date, pad);
          string.push(c);
          j = i + 1;
        }
      }

      string.push(specifier.slice(j, i));
      return string.join("");
    };
  }

  function newParse(specifier, newDate) {
    return function(string) {
      var d = newYear(1900),
          i = parseSpecifier(d, specifier, string += "", 0),
          week, day$1;
      if (i != string.length) return null;

      // If a UNIX timestamp is specified, return it.
      if ("Q" in d) return new Date(d.Q);

      // The am-pm flag is 0 for AM, and 1 for PM.
      if ("p" in d) d.H = d.H % 12 + d.p * 12;

      // Convert day-of-week and week-of-year to day-of-year.
      if ("V" in d) {
        if (d.V < 1 || d.V > 53) return null;
        if (!("w" in d)) d.w = 1;
        if ("Z" in d) {
          week = utcDate(newYear(d.y)), day$1 = week.getUTCDay();
          week = day$1 > 4 || day$1 === 0 ? utcMonday.ceil(week) : utcMonday(week);
          week = utcDay.offset(week, (d.V - 1) * 7);
          d.y = week.getUTCFullYear();
          d.m = week.getUTCMonth();
          d.d = week.getUTCDate() + (d.w + 6) % 7;
        } else {
          week = newDate(newYear(d.y)), day$1 = week.getDay();
          week = day$1 > 4 || day$1 === 0 ? monday.ceil(week) : monday(week);
          week = day.offset(week, (d.V - 1) * 7);
          d.y = week.getFullYear();
          d.m = week.getMonth();
          d.d = week.getDate() + (d.w + 6) % 7;
        }
      } else if ("W" in d || "U" in d) {
        if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0;
        day$1 = "Z" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay();
        d.m = 0;
        d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day$1 + 5) % 7 : d.w + d.U * 7 - (day$1 + 6) % 7;
      }

      // If a time zone is specified, all fields are interpreted as UTC and then
      // offset according to the specified time zone.
      if ("Z" in d) {
        d.H += d.Z / 100 | 0;
        d.M += d.Z % 100;
        return utcDate(d);
      }

      // Otherwise, all fields are in local time.
      return newDate(d);
    };
  }

  function parseSpecifier(d, specifier, string, j) {
    var i = 0,
        n = specifier.length,
        m = string.length,
        c,
        parse;

    while (i < n) {
      if (j >= m) return -1;
      c = specifier.charCodeAt(i++);
      if (c === 37) {
        c = specifier.charAt(i++);
        parse = parses[c in pads ? specifier.charAt(i++) : c];
        if (!parse || ((j = parse(d, string, j)) < 0)) return -1;
      } else if (c != string.charCodeAt(j++)) {
        return -1;
      }
    }

    return j;
  }

  function parsePeriod(d, string, i) {
    var n = periodRe.exec(string.slice(i));
    return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1;
  }

  function parseShortWeekday(d, string, i) {
    var n = shortWeekdayRe.exec(string.slice(i));
    return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;
  }

  function parseWeekday(d, string, i) {
    var n = weekdayRe.exec(string.slice(i));
    return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1;
  }

  function parseShortMonth(d, string, i) {
    var n = shortMonthRe.exec(string.slice(i));
    return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1;
  }

  function parseMonth(d, string, i) {
    var n = monthRe.exec(string.slice(i));
    return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1;
  }

  function parseLocaleDateTime(d, string, i) {
    return parseSpecifier(d, locale_dateTime, string, i);
  }

  function parseLocaleDate(d, string, i) {
    return parseSpecifier(d, locale_date, string, i);
  }

  function parseLocaleTime(d, string, i) {
    return parseSpecifier(d, locale_time, string, i);
  }

  function formatShortWeekday(d) {
    return locale_shortWeekdays[d.getDay()];
  }

  function formatWeekday(d) {
    return locale_weekdays[d.getDay()];
  }

  function formatShortMonth(d) {
    return locale_shortMonths[d.getMonth()];
  }

  function formatMonth(d) {
    return locale_months[d.getMonth()];
  }

  function formatPeriod(d) {
    return locale_periods[+(d.getHours() >= 12)];
  }

  function formatUTCShortWeekday(d) {
    return locale_shortWeekdays[d.getUTCDay()];
  }

  function formatUTCWeekday(d) {
    return locale_weekdays[d.getUTCDay()];
  }

  function formatUTCShortMonth(d) {
    return locale_shortMonths[d.getUTCMonth()];
  }

  function formatUTCMonth(d) {
    return locale_months[d.getUTCMonth()];
  }

  function formatUTCPeriod(d) {
    return locale_periods[+(d.getUTCHours() >= 12)];
  }

  return {
    format: function(specifier) {
      var f = newFormat(specifier += "", formats);
      f.toString = function() { return specifier; };
      return f;
    },
    parse: function(specifier) {
      var p = newParse(specifier += "", localDate);
      p.toString = function() { return specifier; };
      return p;
    },
    utcFormat: function(specifier) {
      var f = newFormat(specifier += "", utcFormats);
      f.toString = function() { return specifier; };
      return f;
    },
    utcParse: function(specifier) {
      var p = newParse(specifier, utcDate);
      p.toString = function() { return specifier; };
      return p;
    }
  };
}

var pads = {"-": "", "_": " ", "0": "0"},
    numberRe = /^\s*\d+/, // note: ignores next directive
    percentRe = /^%/,
    requoteRe = /[\\^$*+?|[\]().{}]/g;

function pad(value, fill, width) {
  var sign = value < 0 ? "-" : "",
      string = (sign ? -value : value) + "",
      length = string.length;
  return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
}

function requote(s) {
  return s.replace(requoteRe, "\\$&");
}

function formatRe(names) {
  return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
}

function formatLookup(names) {
  var map = {}, i = -1, n = names.length;
  while (++i < n) map[names[i].toLowerCase()] = i;
  return map;
}

function parseWeekdayNumberSunday(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 1));
  return n ? (d.w = +n[0], i + n[0].length) : -1;
}

function parseWeekdayNumberMonday(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 1));
  return n ? (d.u = +n[0], i + n[0].length) : -1;
}

function parseWeekNumberSunday(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.U = +n[0], i + n[0].length) : -1;
}

function parseWeekNumberISO(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.V = +n[0], i + n[0].length) : -1;
}

function parseWeekNumberMonday(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.W = +n[0], i + n[0].length) : -1;
}

function parseFullYear(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 4));
  return n ? (d.y = +n[0], i + n[0].length) : -1;
}

function parseYear(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;
}

function parseZone(d, string, i) {
  var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6));
  return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1;
}

function parseMonthNumber(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
}

function parseDayOfMonth(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.d = +n[0], i + n[0].length) : -1;
}

function parseDayOfYear(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 3));
  return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
}

function parseHour24(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.H = +n[0], i + n[0].length) : -1;
}

function parseMinutes(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.M = +n[0], i + n[0].length) : -1;
}

function parseSeconds(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 2));
  return n ? (d.S = +n[0], i + n[0].length) : -1;
}

function parseMilliseconds(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 3));
  return n ? (d.L = +n[0], i + n[0].length) : -1;
}

function parseMicroseconds(d, string, i) {
  var n = numberRe.exec(string.slice(i, i + 6));
  return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1;
}

function parseLiteralPercent(d, string, i) {
  var n = percentRe.exec(string.slice(i, i + 1));
  return n ? i + n[0].length : -1;
}

function parseUnixTimestamp(d, string, i) {
  var n = numberRe.exec(string.slice(i));
  return n ? (d.Q = +n[0], i + n[0].length) : -1;
}

function parseUnixTimestampSeconds(d, string, i) {
  var n = numberRe.exec(string.slice(i));
  return n ? (d.Q = (+n[0]) * 1000, i + n[0].length) : -1;
}

function formatDayOfMonth(d, p) {
  return pad(d.getDate(), p, 2);
}

function formatHour24(d, p) {
  return pad(d.getHours(), p, 2);
}

function formatHour12(d, p) {
  return pad(d.getHours() % 12 || 12, p, 2);
}

function formatDayOfYear(d, p) {
  return pad(1 + day.count(year(d), d), p, 3);
}

function formatMilliseconds(d, p) {
  return pad(d.getMilliseconds(), p, 3);
}

function formatMicroseconds(d, p) {
  return formatMilliseconds(d, p) + "000";
}

function formatMonthNumber(d, p) {
  return pad(d.getMonth() + 1, p, 2);
}

function formatMinutes(d, p) {
  return pad(d.getMinutes(), p, 2);
}

function formatSeconds(d, p) {
  return pad(d.getSeconds(), p, 2);
}

function formatWeekdayNumberMonday(d) {
  var day = d.getDay();
  return day === 0 ? 7 : day;
}

function formatWeekNumberSunday(d, p) {
  return pad(sunday.count(year(d), d), p, 2);
}

function formatWeekNumberISO(d, p) {
  var day = d.getDay();
  d = (day >= 4 || day === 0) ? thursday(d) : thursday.ceil(d);
  return pad(thursday.count(year(d), d) + (year(d).getDay() === 4), p, 2);
}

function formatWeekdayNumberSunday(d) {
  return d.getDay();
}

function formatWeekNumberMonday(d, p) {
  return pad(monday.count(year(d), d), p, 2);
}

function formatYear(d, p) {
  return pad(d.getFullYear() % 100, p, 2);
}

function formatFullYear(d, p) {
  return pad(d.getFullYear() % 10000, p, 4);
}

function formatZone(d) {
  var z = d.getTimezoneOffset();
  return (z > 0 ? "-" : (z *= -1, "+"))
      + pad(z / 60 | 0, "0", 2)
      + pad(z % 60, "0", 2);
}

function formatUTCDayOfMonth(d, p) {
  return pad(d.getUTCDate(), p, 2);
}

function formatUTCHour24(d, p) {
  return pad(d.getUTCHours(), p, 2);
}

function formatUTCHour12(d, p) {
  return pad(d.getUTCHours() % 12 || 12, p, 2);
}

function formatUTCDayOfYear(d, p) {
  return pad(1 + utcDay.count(utcYear(d), d), p, 3);
}

function formatUTCMilliseconds(d, p) {
  return pad(d.getUTCMilliseconds(), p, 3);
}

function formatUTCMicroseconds(d, p) {
  return formatUTCMilliseconds(d, p) + "000";
}

function formatUTCMonthNumber(d, p) {
  return pad(d.getUTCMonth() + 1, p, 2);
}

function formatUTCMinutes(d, p) {
  return pad(d.getUTCMinutes(), p, 2);
}

function formatUTCSeconds(d, p) {
  return pad(d.getUTCSeconds(), p, 2);
}

function formatUTCWeekdayNumberMonday(d) {
  var dow = d.getUTCDay();
  return dow === 0 ? 7 : dow;
}

function formatUTCWeekNumberSunday(d, p) {
  return pad(utcSunday.count(utcYear(d), d), p, 2);
}

function formatUTCWeekNumberISO(d, p) {
  var day = d.getUTCDay();
  d = (day >= 4 || day === 0) ? utcThursday(d) : utcThursday.ceil(d);
  return pad(utcThursday.count(utcYear(d), d) + (utcYear(d).getUTCDay() === 4), p, 2);
}

function formatUTCWeekdayNumberSunday(d) {
  return d.getUTCDay();
}

function formatUTCWeekNumberMonday(d, p) {
  return pad(utcMonday.count(utcYear(d), d), p, 2);
}

function formatUTCYear(d, p) {
  return pad(d.getUTCFullYear() % 100, p, 2);
}

function formatUTCFullYear(d, p) {
  return pad(d.getUTCFullYear() % 10000, p, 4);
}

function formatUTCZone() {
  return "+0000";
}

function formatLiteralPercent() {
  return "%";
}

function formatUnixTimestamp(d) {
  return +d;
}

function formatUnixTimestampSeconds(d) {
  return Math.floor(+d / 1000);
}

var locale;
var timeFormat;
var timeParse;
var utcFormat;
var utcParse;

defaultLocale({
  dateTime: "%x, %X",
  date: "%-m/%-d/%Y",
  time: "%-I:%M:%S %p",
  periods: ["AM", "PM"],
  days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
  shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
  months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
  shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
});

function defaultLocale(definition) {
  locale = formatLocale(definition);
  timeFormat = locale.format;
  timeParse = locale.parse;
  utcFormat = locale.utcFormat;
  utcParse = locale.utcParse;
  return locale;
}

var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ";

function formatIsoNative(date) {
  return date.toISOString();
}

var formatIso = Date.prototype.toISOString
    ? formatIsoNative
    : utcFormat(isoSpecifier);

function parseIsoNative(string) {
  var date = new Date(string);
  return isNaN(date) ? null : date;
}

var parseIso = +new Date("2000-01-01T00:00:00.000Z")
    ? parseIsoNative
    : utcParse(isoSpecifier);

var ECLGraph = /** @class */ (function (_super) {
    __extends(ECLGraph, _super);
    function ECLGraph(wu, eclGraph, eclTimers) {
        var _this = _super.call(this) || this;
        _this.wu = wu;
        var duration = 0;
        for (var _i = 0, eclTimers_1 = eclTimers; _i < eclTimers_1.length; _i++) {
            var eclTimer = eclTimers_1[_i];
            if (eclTimer.GraphName === eclGraph.Name && !eclTimer.HasSubGraphId) {
                duration = Math.round(eclTimer.Seconds * 1000) / 1000;
                break;
            }
        }
        _this.set(__assign({ Time: duration }, eclGraph));
        return _this;
    }
    Object.defineProperty(ECLGraph.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Label", {
        get: function () { return this.get("Label"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Type", {
        get: function () { return this.get("Type"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Complete", {
        get: function () { return this.get("Complete"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "WhenStarted", {
        get: function () { return this.get("WhenStarted"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "WhenFinished", {
        get: function () { return this.get("WhenFinished"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Time", {
        get: function () { return this.get("Time"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Running", {
        get: function () { return this.get("Running"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "RunningId", {
        get: function () { return this.get("RunningId"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(ECLGraph.prototype, "Failed", {
        get: function () { return this.get("Failed"); },
        enumerable: false,
        configurable: true
    });
    ECLGraph.prototype.fetchScopeGraph = function (subgraphID) {
        if (subgraphID) {
            return this.wu.fetchGraphDetails([subgraphID], ["subgraph"]).then(function (scopes) {
                return createGraph(scopes);
            });
        }
        return this.wu.fetchGraphDetails([this.Name], ["graph"]).then(function (scopes) {
            return createGraph(scopes);
        });
    };
    return ECLGraph;
}(StateObject));
var GraphCache = /** @class */ (function (_super) {
    __extends(GraphCache, _super);
    function GraphCache() {
        return _super.call(this, function (obj) {
            return Cache.hash([obj.Name]);
        }) || this;
    }
    return GraphCache;
}(Cache));
function walkXmlJson(node, callback, stack) {
    stack = stack || [];
    stack.push(node);
    callback(node.name, node.$, node.children(), stack);
    node.children().forEach(function (childNode) {
        walkXmlJson(childNode, callback, stack);
    });
    stack.pop();
}
function flattenAtt(nodes) {
    var retVal = {};
    nodes.forEach(function (node) {
        if (node.name === "att") {
            retVal[node.$["name"]] = node.$["value"];
        }
    });
    return retVal;
}
var XGMMLGraph = /** @class */ (function (_super) {
    __extends(XGMMLGraph, _super);
    function XGMMLGraph() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return XGMMLGraph;
}(Graph));
var XGMMLSubgraph = /** @class */ (function (_super) {
    __extends(XGMMLSubgraph, _super);
    function XGMMLSubgraph() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return XGMMLSubgraph;
}(Subgraph));
var XGMMLVertex = /** @class */ (function (_super) {
    __extends(XGMMLVertex, _super);
    function XGMMLVertex() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return XGMMLVertex;
}(Vertex));
var XGMMLEdge = /** @class */ (function (_super) {
    __extends(XGMMLEdge, _super);
    function XGMMLEdge() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return XGMMLEdge;
}(Edge));
function createXGMMLGraph(id, graphs) {
    var subgraphs = {};
    var vertices = {};
    var edges = {};
    var graph = new XGMMLGraph(function (item) {
        return item._["id"];
    });
    var stack = [graph.root];
    walkXmlJson(graphs, function (tag, attributes, childNodes, _stack) {
        var top = stack[stack.length - 1];
        switch (tag) {
            case "graph":
                break;
            case "node":
                if (childNodes.length && childNodes[0].children().length && childNodes[0].children()[0].name === "graph") {
                    var subgraph = top.createSubgraph(flattenAtt(childNodes));
                    stack.push(subgraph);
                    subgraphs[attributes["id"]] = subgraph;
                }
                // TODO:  Is this really a node when its also a subgraph?
                var vertex = top.createVertex(flattenAtt(childNodes));
                vertices[attributes["id"]] = vertex;
                break;
            case "edge":
                var edge = top.createEdge(vertices[attributes["source"]], vertices[attributes["target"]], flattenAtt(childNodes));
                edges[attributes["id"]] = edge;
                break;
        }
    });
    return graph;
}
var ScopeGraph = /** @class */ (function (_super) {
    __extends(ScopeGraph, _super);
    function ScopeGraph() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ScopeGraph;
}(Graph));
var ScopeSubgraph = /** @class */ (function (_super) {
    __extends(ScopeSubgraph, _super);
    function ScopeSubgraph() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ScopeSubgraph;
}(Subgraph));
var ScopeVertex = /** @class */ (function (_super) {
    __extends(ScopeVertex, _super);
    function ScopeVertex() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ScopeVertex;
}(Vertex));
var ScopeEdge = /** @class */ (function (_super) {
    __extends(ScopeEdge, _super);
    function ScopeEdge() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return ScopeEdge;
}(Edge));
function createGraph(scopes) {
    var subgraphs = {};
    var edges = {};
    var graph;
    for (var _i = 0, scopes_1 = scopes; _i < scopes_1.length; _i++) {
        var scope = scopes_1[_i];
        switch (scope.ScopeType) {
            case "graph":
                graph = new ScopeGraph(function (item) { return item._.Id; }, scope);
                subgraphs[scope.ScopeName] = graph.root;
                break;
            case "subgraph":
                if (!graph) {
                    graph = new ScopeGraph(function (item) { return item._.Id; }, scope);
                    subgraphs[scope.ScopeName] = graph.root;
                }
                var scopeStack = scope.parentScope().split(":");
                var scopeParent1 = subgraphs[scope.parentScope()];
                while (scopeStack.length && !scopeParent1) {
                    scopeParent1 = subgraphs[scopeStack.join(":")];
                    scopeStack.pop();
                }
                if (!scopeParent1) {
                    console.log("Missing SG:Parent (" + scope.Id + "): " + scope.parentScope());
                }
                else {
                    var parent1 = scopeParent1;
                    subgraphs[scope.ScopeName] = parent1.createSubgraph(scope);
                }
                break;
            case "activity":
                var scopeParent2 = subgraphs[scope.parentScope()];
                if (!scopeParent2) {
                    console.log("Missing A:Parent (" + scope.Id + "): " + scope.parentScope());
                }
                else {
                    scopeParent2.createVertex(scope);
                }
                break;
            case "edge":
                edges[scope.ScopeName] = scope;
                break;
        }
    }
    for (var id in edges) {
        var scope = edges[id];
        var scopeParent3 = subgraphs[scope.parentScope()];
        if (!scopeParent3) {
            console.log("Missing E:Parent (" + scope.Id + "): " + scope.parentScope());
        }
        else {
            var parent3 = scopeParent3;
            try {
                var source = graph.vertex(scope.attr("IdSource").RawValue);
                var target = graph.vertex(scope.attr("IdTarget").RawValue);
                parent3.createEdge(source, target, scope);
            }
            catch (e) {
                // const sourceIndex = scope.attr("SourceIndex").RawValue;
                // const targetIndex = scope.attr("TargetIndex").RawValue;
                console.log("Invalid Edge: " + id);
            }
        }
    }
    return graph;
}

var Resource = /** @class */ (function (_super) {
    __extends(Resource, _super);
    function Resource(wu, url) {
        var _this = _super.call(this) || this;
        _this.wu = wu;
        var cleanedURL = url.split("\\").join("/");
        var urlParts = cleanedURL.split("/");
        var matchStr = "res/" + _this.wu.Wuid + "/";
        var displayPath = "";
        var displayName = "";
        if (cleanedURL.indexOf(matchStr) === 0) {
            displayPath = cleanedURL.substr(matchStr.length);
            displayName = urlParts[urlParts.length - 1];
        }
        _this.set({
            URL: url,
            DisplayName: displayName,
            DisplayPath: displayPath
        });
        return _this;
    }
    Object.defineProperty(Resource.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Resource.prototype, "URL", {
        get: function () { return this.get("URL"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Resource.prototype, "DisplayName", {
        get: function () { return this.get("DisplayName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Resource.prototype, "DisplayPath", {
        get: function () { return this.get("DisplayPath"); },
        enumerable: false,
        configurable: true
    });
    return Resource;
}(StateObject));

var XSDNode = /** @class */ (function () {
    function XSDNode(e) {
        this.e = e;
    }
    XSDNode.prototype.fix = function () {
        delete this.e;
    };
    return XSDNode;
}());
var XSDXMLNode = /** @class */ (function (_super) {
    __extends(XSDXMLNode, _super);
    function XSDXMLNode(e) {
        var _this = _super.call(this, e) || this;
        _this.attrs = {};
        _this._children = [];
        return _this;
    }
    XSDXMLNode.prototype.append = function (child) {
        this._children.push(child);
        if (!this.type) {
            this.type = "hpcc:childDataset";
        }
    };
    XSDXMLNode.prototype.fix = function () {
        var _a;
        this.name = this.e.$["name"];
        this.type = this.e.$["type"];
        for (var i = this._children.length - 1; i >= 0; --i) {
            var row = this._children[i];
            if (row.name === "Row" && row.type === undefined) {
                (_a = this._children).push.apply(_a, row._children);
                this._children.splice(i, 1);
            }
        }
        _super.prototype.fix.call(this);
    };
    XSDXMLNode.prototype.children = function () {
        return this._children;
    };
    XSDXMLNode.prototype.charWidth = function () {
        var retVal = -1;
        switch (this.type) {
            case "xs:boolean":
                retVal = 5;
                break;
            case "xs:integer":
                retVal = 8;
                break;
            case "xs:nonNegativeInteger":
                retVal = 8;
                break;
            case "xs:double":
                retVal = 8;
                break;
            case "xs:string":
                retVal = 32;
                break;
            default:
                var numStr = "0123456789";
                var underbarPos = this.type.lastIndexOf("_");
                var length_1 = underbarPos > 0 ? underbarPos : this.type.length;
                var i = length_1 - 1;
                for (; i >= 0; --i) {
                    if (numStr.indexOf(this.type.charAt(i)) === -1)
                        break;
                }
                if (i + 1 < length_1) {
                    retVal = parseInt(this.type.substring(i + 1, length_1), 10);
                }
                if (this.type.indexOf("data") === 0) {
                    retVal *= 2;
                }
                break;
        }
        if (retVal < this.name.length)
            retVal = this.name.length;
        return retVal;
    };
    return XSDXMLNode;
}(XSDNode));
var XSDSimpleType = /** @class */ (function (_super) {
    __extends(XSDSimpleType, _super);
    function XSDSimpleType(e) {
        return _super.call(this, e) || this;
    }
    XSDSimpleType.prototype.append = function (e) {
        switch (e.name) {
            case "xs:restriction":
                this._restricition = e;
                break;
            case "xs:maxLength":
                this._maxLength = e;
                break;
        }
    };
    XSDSimpleType.prototype.fix = function () {
        this.name = this.e.$["name"];
        this.type = this._restricition.$["base"];
        this.maxLength = this._maxLength ? +this._maxLength.$["value"] : undefined;
        delete this._restricition;
        delete this._maxLength;
        _super.prototype.fix.call(this);
    };
    return XSDSimpleType;
}(XSDNode));
var XSDSchema = /** @class */ (function () {
    function XSDSchema() {
        this.simpleTypes = {};
    }
    XSDSchema.prototype.fields = function () {
        return this.root.children();
    };
    return XSDSchema;
}());
var XSDParser = /** @class */ (function (_super) {
    __extends(XSDParser, _super);
    function XSDParser() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.schema = new XSDSchema();
        _this.simpleTypes = {};
        _this.xsdStack = new Stack();
        return _this;
    }
    XSDParser.prototype.startXMLNode = function (e) {
        _super.prototype.startXMLNode.call(this, e);
        switch (e.name) {
            case "xs:element":
                var xsdXMLNode = new XSDXMLNode(e);
                if (!this.schema.root) {
                    this.schema.root = xsdXMLNode;
                }
                else if (this.xsdStack.depth()) {
                    this.xsdStack.top().append(xsdXMLNode);
                }
                this.xsdStack.push(xsdXMLNode);
                break;
            case "xs:simpleType":
                this.simpleType = new XSDSimpleType(e);
                break;
        }
    };
    XSDParser.prototype.endXMLNode = function (e) {
        switch (e.name) {
            case "xs:element":
                var xsdXMLNode = this.xsdStack.pop();
                xsdXMLNode.fix();
                break;
            case "xs:simpleType":
                this.simpleType.fix();
                this.simpleTypes[this.simpleType.name] = this.simpleType;
                delete this.simpleType;
                break;
            case "xs:appinfo":
                var xsdXMLNode2 = this.xsdStack.top();
                for (var key in e.$) {
                    xsdXMLNode2.attrs[key] = e.$[key];
                }
                break;
            default:
                if (this.simpleType) {
                    this.simpleType.append(e);
                }
        }
        _super.prototype.endXMLNode.call(this, e);
    };
    return XSDParser;
}(SAXStackParser));
function parseXSD(xml) {
    var saxParser = new XSDParser();
    saxParser.parse(xml);
    return saxParser.schema;
}
var XSDParser2 = /** @class */ (function (_super) {
    __extends(XSDParser2, _super);
    function XSDParser2(rootName) {
        var _this = _super.call(this) || this;
        _this.schema = new XSDSchema();
        _this.simpleTypes = {};
        _this.xsdStack = new Stack();
        _this._rootName = rootName;
        return _this;
    }
    XSDParser2.prototype.startXMLNode = function (e) {
        _super.prototype.startXMLNode.call(this, e);
        switch (e.name) {
            case "xsd:element":
                var xsdXMLNode = new XSDXMLNode(e);
                if (!this.schema.root && this._rootName === e.$.name) {
                    this.schema.root = xsdXMLNode;
                }
                if (this.xsdStack.depth()) {
                    this.xsdStack.top().append(xsdXMLNode);
                }
                this.xsdStack.push(xsdXMLNode);
                break;
            case "xsd:simpleType":
                this.simpleType = new XSDSimpleType(e);
                break;
        }
    };
    XSDParser2.prototype.endXMLNode = function (e) {
        switch (e.name) {
            case "xsd:element":
                var xsdXMLNode = this.xsdStack.pop();
                xsdXMLNode.fix();
                break;
        }
        _super.prototype.endXMLNode.call(this, e);
    };
    return XSDParser2;
}(XSDParser));
function parseXSD2(xml, rootName) {
    var saxParser = new XSDParser2(rootName);
    saxParser.parse(xml);
    return saxParser.schema;
}

var GlobalResultCache = /** @class */ (function (_super) {
    __extends(GlobalResultCache, _super);
    function GlobalResultCache() {
        return _super.call(this, function (obj) {
            return obj.BaseUrl + "-" + obj.Wuid + "-" + obj.ResultName;
        }) || this;
    }
    return GlobalResultCache;
}(Cache));
var _results = new GlobalResultCache();
var Result = /** @class */ (function (_super) {
    __extends(Result, _super);
    function Result(optsConnection, wuidOrLogicalFile, eclResultOrResultName, resultViews) {
        if (resultViews === void 0) { resultViews = []; }
        var _this = _super.call(this) || this;
        if (optsConnection instanceof WorkunitsService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new WorkunitsService(optsConnection);
        }
        if (typeof eclResultOrResultName === "undefined") {
            _this.set({
                LogicalFileName: wuidOrLogicalFile
            });
        }
        else if (typeof eclResultOrResultName === "string") {
            _this.set({
                Wuid: wuidOrLogicalFile,
                ResultName: eclResultOrResultName,
                ResultViews: resultViews
            });
        }
        else if (typeof eclResultOrResultName === "number") {
            _this.set({
                Wuid: wuidOrLogicalFile,
                ResultSequence: eclResultOrResultName,
                ResultViews: resultViews
            });
        }
        else {
            _this.set(__assign({ Wuid: wuidOrLogicalFile, ResultName: eclResultOrResultName.Name, ResultViews: resultViews }, eclResultOrResultName));
        }
        return _this;
    }
    Object.defineProperty(Result.prototype, "BaseUrl", {
        get: function () { return this.connection.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "Wuid", {
        get: function () { return this.get("Wuid"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "ResultName", {
        get: function () { return this.get("ResultName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "ResultSequence", {
        get: function () { return this.get("ResultSequence"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "LogicalFileName", {
        get: function () { return this.get("LogicalFileName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "Sequence", {
        get: function () { return this.get("Sequence"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "Value", {
        get: function () { return this.get("Value"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "Link", {
        get: function () { return this.get("Link"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "FileName", {
        get: function () { return this.get("FileName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "IsSupplied", {
        get: function () { return this.get("IsSupplied"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "ShowFileContent", {
        get: function () { return this.get("ShowFileContent"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "Total", {
        get: function () { return this.get("Total"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "ECLSchemas", {
        get: function () { return this.get("ECLSchemas"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "NodeGroup", {
        get: function () { return this.get("NodeGroup"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "ResultViews", {
        get: function () { return this.get("ResultViews"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Result.prototype, "XmlSchema", {
        get: function () { return this.get("XmlSchema"); },
        enumerable: false,
        configurable: true
    });
    Result.attach = function (optsConnection, wuid, resultName, state) {
        var retVal = _results.get({ BaseUrl: optsConnection.baseUrl, Wuid: wuid, ResultName: resultName }, function () {
            return new Result(optsConnection, wuid, resultName);
        });
        if (state) {
            retVal.set(state);
        }
        return retVal;
    };
    Result.prototype.isComplete = function () {
        return this.Total !== -1;
    };
    Result.prototype.fetchXMLSchema = function () {
        var _this = this;
        if (this.xsdSchema) {
            return Promise.resolve(this.xsdSchema);
        }
        return this.WUResult().then(function (response) {
            if (exists("Result.XmlSchema.xml", response)) {
                _this.xsdSchema = parseXSD(response.Result.XmlSchema.xml);
                return _this.xsdSchema;
            }
            return null;
        });
    };
    Result.prototype.refresh = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.fetchRows(0, 1, true)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, this];
                }
            });
        });
    };
    Result.prototype.fetchRows = function (from, count, includeSchema, filter) {
        var _this = this;
        if (from === void 0) { from = 0; }
        if (count === void 0) { count = -1; }
        if (includeSchema === void 0) { includeSchema = false; }
        if (filter === void 0) { filter = {}; }
        return this.WUResult(from, count, !includeSchema, filter).then(function (response) {
            var result = response.Result;
            delete response.Result; //  Do not want it in "set"
            _this.set(__assign({}, response));
            if (exists("XmlSchema.xml", result)) {
                _this.xsdSchema = parseXSD(result.XmlSchema.xml);
            }
            if (exists("Row", result)) {
                return result.Row;
            }
            else if (_this.ResultName && exists(_this.ResultName, result)) {
                return result[_this.ResultName].Row;
            }
            return [];
        });
    };
    Result.prototype.rootField = function () {
        if (!this.xsdSchema)
            return null;
        return this.xsdSchema.root;
    };
    Result.prototype.fields = function () {
        if (!this.xsdSchema)
            return [];
        return this.xsdSchema.root.children();
    };
    Result.prototype.WUResult = function (start, count, suppressXmlSchema, filter) {
        if (start === void 0) { start = 0; }
        if (count === void 0) { count = 1; }
        if (suppressXmlSchema === void 0) { suppressXmlSchema = false; }
        if (filter === void 0) { filter = {}; }
        var FilterBy = {
            NamedValue: {
                itemcount: 0
            }
        };
        for (var key in filter) {
            FilterBy.NamedValue[FilterBy.NamedValue.itemcount++] = {
                Name: key,
                Value: filter[key]
            };
        }
        var request = { FilterBy: FilterBy };
        if (this.Wuid && this.ResultName !== undefined) {
            request.Wuid = this.Wuid;
            request.ResultName = this.ResultName;
        }
        else if (this.Wuid && this.ResultSequence !== undefined) {
            request.Wuid = this.Wuid;
            request.Sequence = this.ResultSequence;
        }
        else if (this.LogicalFileName && this.NodeGroup) {
            request.LogicalName = this.LogicalFileName;
            request.Cluster = this.NodeGroup;
        }
        else if (this.LogicalFileName) {
            request.LogicalName = this.LogicalFileName;
        }
        request.Start = start;
        request.Count = count;
        request.SuppressXmlSchema = suppressXmlSchema;
        return this.connection.WUResult(request).then(function (response) {
            return response;
        });
    };
    return Result;
}(StateObject));
var ResultCache = /** @class */ (function (_super) {
    __extends(ResultCache, _super);
    function ResultCache() {
        return _super.call(this, function (obj) {
            return Cache.hash([obj.Sequence, obj.Name, obj.FileName]);
        }) || this;
    }
    return ResultCache;
}(Cache));

var Attribute = /** @class */ (function (_super) {
    __extends(Attribute, _super);
    function Attribute(scope, attribute) {
        var _this = _super.call(this) || this;
        _this.scope = scope;
        _this.set(attribute);
        return _this;
    }
    Object.defineProperty(Attribute.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "RawValue", {
        get: function () { return this.get("RawValue"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "Formatted", {
        get: function () { return this.get("Formatted"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "FormattedEnd", {
        get: function () { return this.get("FormattedEnd"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "Measure", {
        get: function () { return this.get("Measure"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "Creator", {
        get: function () { return this.get("Creator"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Attribute.prototype, "CreatorType", {
        get: function () { return this.get("CreatorType"); },
        enumerable: false,
        configurable: true
    });
    return Attribute;
}(StateObject));
var BaseScope = /** @class */ (function (_super) {
    __extends(BaseScope, _super);
    function BaseScope(scope) {
        var _this = _super.call(this) || this;
        _this._attributeMap = {};
        _this._children = [];
        _this.update(scope);
        return _this;
    }
    Object.defineProperty(BaseScope.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(BaseScope.prototype, "ScopeName", {
        get: function () { return this.get("ScopeName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(BaseScope.prototype, "Id", {
        get: function () { return this.get("Id"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(BaseScope.prototype, "ScopeType", {
        get: function () { return this.get("ScopeType"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(BaseScope.prototype, "Properties", {
        get: function () { return this.get("Properties", { Property: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(BaseScope.prototype, "CAttributes", {
        get: function () {
            var _this = this;
            //  Match "started" and time elapsed
            var retVal = [];
            var timeElapsed = {
                start: null,
                end: null
            };
            this.Properties.Property.forEach(function (scopeAttr) {
                if (scopeAttr.Measure === "ts" && scopeAttr.Name.indexOf("Started") >= 0) {
                    timeElapsed.start = scopeAttr;
                }
                else if (_this.ScopeName && scopeAttr.Measure === "ts" && scopeAttr.Name.indexOf("Finished") >= 0) {
                    timeElapsed.end = scopeAttr;
                }
                else {
                    retVal.push(new Attribute(_this, scopeAttr));
                }
            });
            if (timeElapsed.start && timeElapsed.end) {
                // const endTime = parser(timeElapsed.start.Formatted);
                // endTime!.setMilliseconds(endTime!.getMilliseconds() + (+timeElapsed.elapsed.RawValue) / 1000000);
                // timeElapsed.start.FormattedEnd = formatter(endTime!);
                timeElapsed.start.FormattedEnd = timeElapsed.end.Formatted;
                retVal.push(new Attribute(this, timeElapsed.start));
            }
            else if (timeElapsed.start) {
                retVal.push(new Attribute(this, timeElapsed.start));
            }
            else if (timeElapsed.end) {
                retVal.push(new Attribute(this, timeElapsed.end)); //  Should not happen?
            }
            return retVal;
        },
        enumerable: false,
        configurable: true
    });
    BaseScope.prototype.update = function (scope) {
        var _this = this;
        this.set(scope);
        this.CAttributes.forEach(function (attr) {
            _this._attributeMap[attr.Name] = attr;
        });
        this.Properties.Property = [];
        for (var key in this._attributeMap) {
            if (this._attributeMap.hasOwnProperty(key)) {
                this.Properties.Property.push(this._attributeMap[key].properties);
            }
        }
    };
    BaseScope.prototype.parentScope = function () {
        var scopeParts = this.ScopeName.split(":");
        scopeParts.pop();
        return scopeParts.join(":");
    };
    BaseScope.prototype.children = function (_) {
        if (!arguments.length)
            return this._children;
        this._children = _;
        return this;
    };
    BaseScope.prototype.walk = function (visitor) {
        if (visitor.start(this))
            return true;
        for (var _i = 0, _a = this.children(); _i < _a.length; _i++) {
            var scope = _a[_i];
            if (scope.walk(visitor)) {
                return true;
            }
        }
        return visitor.end(this);
    };
    BaseScope.prototype.formattedAttrs = function () {
        var retVal = {};
        for (var attr in this._attributeMap) {
            retVal[attr] = this._attributeMap[attr].Formatted || this._attributeMap[attr].RawValue;
        }
        return retVal;
    };
    BaseScope.prototype.rawAttrs = function () {
        var retVal = {};
        for (var attr in this._attributeMap) {
            retVal[attr] = this._attributeMap[attr].RawValue;
        }
        return retVal;
    };
    BaseScope.prototype.hasAttr = function (name) {
        return this._attributeMap[name] !== undefined;
    };
    BaseScope.prototype.attr = function (name) {
        return this._attributeMap[name] || new Attribute(this, {
            Creator: "",
            CreatorType: "",
            Formatted: "",
            Measure: "",
            Name: "",
            RawValue: ""
        });
    };
    BaseScope.prototype.attrMeasure = function (name) {
        return this._attributeMap[name].Measure;
    };
    BaseScope.prototype.calcTooltip = function (parentScope) {
        var label = "";
        var rows = [];
        label = this.Id;
        rows.push("<tr><td class=\"key\">ID:</td><td class=\"value\">" + this.Id + "</td></tr>");
        if (parentScope) {
            rows.push("<tr><td class=\"key\">Parent ID:</td><td class=\"value\">" + parentScope.Id + "</td></tr>");
        }
        rows.push("<tr><td class=\"key\">Scope:</td><td class=\"value\">" + this.ScopeName + "</td></tr>");
        var attrs = this.formattedAttrs();
        for (var key in attrs) {
            if (key === "Label") {
                label = attrs[key];
            }
            else {
                rows.push("<tr><td class=\"key\">" + key + "</td><td class=\"value\">" + attrs[key] + "</td></tr>");
            }
        }
        return "<div class=\"eclwatch_WUGraph_Tooltip\" style=\"max-width:480px\">\n            <h4 align=\"center\">" + label + "</h4>\n            <table>\n                " + rows.join("") + "\n            </table>\n        </div>";
    };
    return BaseScope;
}(StateObject));
var Scope = /** @class */ (function (_super) {
    __extends(Scope, _super);
    function Scope(wu, scope) {
        var _this = _super.call(this, scope) || this;
        _this.wu = wu;
        return _this;
    }
    return Scope;
}(BaseScope));

var SourceFile = /** @class */ (function (_super) {
    __extends(SourceFile, _super);
    function SourceFile(optsConnection, wuid, eclSourceFile) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof WorkunitsService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new WorkunitsService(optsConnection);
        }
        _this.set(__assign({ Wuid: wuid }, eclSourceFile));
        return _this;
    }
    Object.defineProperty(SourceFile.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "Wuid", {
        get: function () { return this.get("Wuid"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "FileCluster", {
        get: function () { return this.get("FileCluster"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "IsSuperFile", {
        get: function () { return this.get("IsSuperFile"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "Subs", {
        get: function () { return this.get("Subs"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "Count", {
        get: function () { return this.get("Count"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(SourceFile.prototype, "ECLSourceFiles", {
        get: function () { return this.get("ECLSourceFiles"); },
        enumerable: false,
        configurable: true
    });
    return SourceFile;
}(StateObject));

var Timer = /** @class */ (function (_super) {
    __extends(Timer, _super);
    function Timer(optsConnection, wuid, eclTimer) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof WorkunitsService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new WorkunitsService(optsConnection);
        }
        var secs = espTime2Seconds(eclTimer.Value);
        _this.set(__assign({ Wuid: wuid, Seconds: Math.round(secs * 1000) / 1000, HasSubGraphId: eclTimer.SubGraphId !== undefined }, eclTimer));
        return _this;
    }
    Object.defineProperty(Timer.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "Wuid", {
        get: function () { return this.get("Wuid"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "Value", {
        get: function () { return this.get("Value"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "Seconds", {
        get: function () { return this.get("Seconds"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "GraphName", {
        get: function () { return this.get("GraphName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "SubGraphId", {
        get: function () { return this.get("SubGraphId"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "HasSubGraphId", {
        get: function () { return this.get("HasSubGraphId"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Timer.prototype, "count", {
        get: function () { return this.get("count"); },
        enumerable: false,
        configurable: true
    });
    return Timer;
}(StateObject));

var formatter = utcFormat("%Y-%m-%dT%H:%M:%S.%LZ");
var parser = utcParse("%Y-%m-%dT%H:%M:%S.%LZ");
var logger$1 = scopedLogger("workunit.ts");
var WUStateID$1 = WUStateID;
var WorkunitCache = /** @class */ (function (_super) {
    __extends(WorkunitCache, _super);
    function WorkunitCache() {
        return _super.call(this, function (obj) {
            return obj.BaseUrl + "-" + obj.Wuid;
        }) || this;
    }
    return WorkunitCache;
}(Cache));
var _workunits = new WorkunitCache();
var Workunit = /** @class */ (function (_super) {
    __extends(Workunit, _super);
    //  ---  ---  ---
    function Workunit(optsConnection, wuid) {
        var _this = _super.call(this) || this;
        _this._debugMode = false;
        _this._resultCache = new ResultCache();
        _this._graphCache = new GraphCache();
        _this.connection = new WorkunitsService(optsConnection);
        _this.topologyConnection = new TopologyService(optsConnection);
        _this.clearState(wuid);
        return _this;
    }
    Object.defineProperty(Workunit.prototype, "BaseUrl", {
        get: function () { return this.connection.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "properties", {
        //  Accessors  ---
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Wuid", {
        get: function () { return this.get("Wuid"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Owner", {
        get: function () { return this.get("Owner", ""); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Cluster", {
        get: function () { return this.get("Cluster", ""); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Jobname", {
        get: function () { return this.get("Jobname", ""); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Description", {
        get: function () { return this.get("Description", ""); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ActionEx", {
        get: function () { return this.get("ActionEx", ""); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "StateID", {
        get: function () { return this.get("StateID", WUStateID.Unknown); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "State", {
        get: function () { return this.get("State") || WUStateID[this.StateID]; },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Protected", {
        get: function () { return this.get("Protected", false); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Exceptions", {
        get: function () { return this.get("Exceptions", { ECLException: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResultViews", {
        get: function () { return this.get("ResultViews", []); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResultCount", {
        get: function () { return this.get("ResultCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Results", {
        get: function () { return this.get("Results", { ECLResult: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "CResults", {
        get: function () {
            var _this = this;
            return this.Results.ECLResult.map(function (eclResult) {
                return _this._resultCache.get(eclResult, function () {
                    return new Result(_this.connection, _this.Wuid, eclResult, _this.ResultViews);
                });
            });
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "SequenceResults", {
        get: function () {
            var retVal = {};
            this.CResults.forEach(function (result) {
                retVal[result.Sequence] = result;
            });
            return retVal;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Timers", {
        get: function () { return this.get("Timers", { ECLTimer: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "CTimers", {
        get: function () {
            var _this = this;
            return this.Timers.ECLTimer.map(function (eclTimer) {
                return new Timer(_this.connection, _this.Wuid, eclTimer);
            });
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "GraphCount", {
        get: function () { return this.get("GraphCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Graphs", {
        get: function () { return this.get("Graphs", { ECLGraph: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "CGraphs", {
        get: function () {
            var _this = this;
            return this.Graphs.ECLGraph.map(function (eclGraph) {
                return _this._graphCache.get(eclGraph, function () {
                    return new ECLGraph(_this, eclGraph, _this.CTimers);
                });
            });
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ThorLogList", {
        get: function () { return this.get("ThorLogList"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResourceURLCount", {
        get: function () { return this.get("ResourceURLCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResourceURLs", {
        get: function () { return this.get("ResourceURLs", { URL: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "CResourceURLs", {
        get: function () {
            var _this = this;
            return this.ResourceURLs.URL.map(function (url) {
                return new Resource(_this, url);
            });
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "TotalClusterTime", {
        get: function () { return this.get("TotalClusterTime", ""); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "DateTimeScheduled", {
        get: function () { return this.get("DateTimeScheduled"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "IsPausing", {
        get: function () { return this.get("IsPausing"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ThorLCR", {
        get: function () { return this.get("ThorLCR"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ApplicationValues", {
        get: function () { return this.get("ApplicationValues", { ApplicationValue: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "HasArchiveQuery", {
        get: function () { return this.get("HasArchiveQuery"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "StateEx", {
        get: function () { return this.get("StateEx"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "PriorityClass", {
        get: function () { return this.get("PriorityClass"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "PriorityLevel", {
        get: function () { return this.get("PriorityLevel"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Snapshot", {
        get: function () { return this.get("Snapshot"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResultLimit", {
        get: function () { return this.get("ResultLimit"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "EventSchedule", {
        get: function () { return this.get("EventSchedule"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "HaveSubGraphTimings", {
        get: function () { return this.get("HaveSubGraphTimings"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Query", {
        get: function () { return this.get("Query"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "HelpersCount", {
        get: function () { return this.get("HelpersCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Helpers", {
        get: function () { return this.get("Helpers", { ECLHelpFile: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "DebugValues", {
        get: function () { return this.get("DebugValues"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "AllowedClusters", {
        get: function () { return this.get("AllowedClusters"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ErrorCount", {
        get: function () { return this.get("ErrorCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "WarningCount", {
        get: function () { return this.get("WarningCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "InfoCount", {
        get: function () { return this.get("InfoCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "AlertCount", {
        get: function () { return this.get("AlertCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "SourceFileCount", {
        get: function () { return this.get("SourceFileCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "SourceFiles", {
        get: function () { return this.get("SourceFiles", { ECLSourceFile: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "CSourceFiles", {
        get: function () {
            var _this = this;
            return this.SourceFiles.ECLSourceFile.map(function (eclSourceFile) { return new SourceFile(_this.connection, _this.Wuid, eclSourceFile); });
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "VariableCount", {
        get: function () { return this.get("VariableCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Variables", {
        get: function () { return this.get("Variables", { ECLResult: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "TimerCount", {
        get: function () { return this.get("TimerCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "HasDebugValue", {
        get: function () { return this.get("HasDebugValue"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ApplicationValueCount", {
        get: function () { return this.get("ApplicationValueCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "XmlParams", {
        get: function () { return this.get("XmlParams"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "AccessFlag", {
        get: function () { return this.get("AccessFlag"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ClusterFlag", {
        get: function () { return this.get("ClusterFlag"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResultViewCount", {
        get: function () { return this.get("ResultViewCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "DebugValueCount", {
        get: function () { return this.get("DebugValueCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "WorkflowCount", {
        get: function () { return this.get("WorkflowCount", 0); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Archived", {
        get: function () { return this.get("Archived"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "RoxieCluster", {
        get: function () { return this.get("RoxieCluster"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "DebugState", {
        get: function () { return this.get("DebugState", {}); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Queue", {
        get: function () { return this.get("Queue"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Active", {
        get: function () { return this.get("Active"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Action", {
        get: function () { return this.get("Action"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Scope", {
        get: function () { return this.get("Scope"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "AbortBy", {
        get: function () { return this.get("AbortBy"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "AbortTime", {
        get: function () { return this.get("AbortTime"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "Workflows", {
        get: function () { return this.get("Workflows"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "TimingData", {
        get: function () { return this.get("TimingData"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "HelpersDesc", {
        get: function () { return this.get("HelpersDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "GraphsDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "SourceFilesDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ResultsDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "VariablesDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "TimersDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "DebugValuesDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "ApplicationValuesDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Workunit.prototype, "WorkflowsDesc", {
        get: function () { return this.get("GraphsDesc"); },
        enumerable: false,
        configurable: true
    });
    //  Factories  ---
    Workunit.create = function (optsConnection) {
        var retVal = new Workunit(optsConnection);
        return retVal.connection.WUCreate().then(function (response) {
            _workunits.set(retVal);
            retVal.set(response.Workunit);
            return retVal;
        });
    };
    Workunit.attach = function (optsConnection, wuid, state) {
        var retVal = _workunits.get({ BaseUrl: optsConnection.baseUrl, Wuid: wuid }, function () {
            return new Workunit(optsConnection, wuid);
        });
        if (state) {
            retVal.set(state);
        }
        return retVal;
    };
    Workunit.existsLocal = function (baseUrl, wuid) {
        return _workunits.has({ BaseUrl: baseUrl, Wuid: wuid });
    };
    Workunit.submit = function (server, target, ecl) {
        return Workunit.create(server).then(function (wu) {
            return wu.update({ QueryText: ecl });
        }).then(function (wu) {
            return wu.submit(target);
        });
    };
    Workunit.query = function (server, opts) {
        var wsWorkunits = new WorkunitsService(server);
        return wsWorkunits.WUQuery(opts).then(function (response) {
            return response.Workunits.ECLWorkunit.map(function (wu) {
                return Workunit.attach(server, wu.Wuid, wu);
            });
        });
    };
    Workunit.prototype.clearState = function (wuid) {
        this.clear({
            Wuid: wuid,
            StateID: WUStateID$1.Unknown
        });
    };
    Workunit.prototype.update = function (request) {
        var _this = this;
        return this.connection.WUUpdate(__assign(__assign({}, request), {
            Wuid: this.Wuid,
            StateOrig: this.State,
            JobnameOrig: this.Jobname,
            DescriptionOrig: this.Description,
            ProtectedOrig: this.Protected,
            ClusterOrig: this.Cluster
        })).then(function (response) {
            _this.set(response.Workunit);
            return _this;
        });
    };
    Workunit.prototype.submit = function (_cluster, action, resultLimit) {
        var _this = this;
        if (action === void 0) { action = WUUpdate.Action.Run; }
        var clusterPromise;
        if (_cluster !== void 0) {
            clusterPromise = Promise.resolve(_cluster);
        }
        else {
            clusterPromise = this.topologyConnection.DefaultTpLogicalClusterQuery().then(function (response) {
                return response.Name;
            });
        }
        this._debugMode = false;
        if (action === WUUpdate.Action.Debug) {
            action = WUUpdate.Action.Run;
            this._debugMode = true;
        }
        return clusterPromise.then(function (cluster) {
            return _this.connection.WUUpdate({
                Wuid: _this.Wuid,
                Action: action,
                ResultLimit: resultLimit,
                DebugValues: {
                    DebugValue: [
                        {
                            Name: "Debug",
                            Value: _this._debugMode ? "1" : ""
                        }
                    ]
                }
            }).then(function (response) {
                _this.set(response.Workunit);
                _this._submitAction = action;
                return _this.connection.WUSubmit({ Wuid: _this.Wuid, Cluster: cluster });
            });
        }).then(function () {
            return _this;
        });
    };
    Workunit.prototype.isComplete = function () {
        switch (this.StateID) {
            case WUStateID$1.Compiled:
                return this.ActionEx === "compile" || this._submitAction === WUUpdate.Action.Compile;
            case WUStateID$1.Completed:
            case WUStateID$1.Failed:
            case WUStateID$1.Aborted:
            case WUStateID$1.NotFound:
                return true;
        }
        return false;
    };
    Workunit.prototype.isFailed = function () {
        switch (this.StateID) {
            case WUStateID$1.Aborted:
            case WUStateID$1.Failed:
                return true;
        }
        return false;
    };
    Workunit.prototype.isDeleted = function () {
        switch (this.StateID) {
            case WUStateID$1.NotFound:
                return true;
        }
        return false;
    };
    Workunit.prototype.isDebugging = function () {
        switch (this.StateID) {
            case WUStateID$1.DebugPaused:
            case WUStateID$1.DebugRunning:
                return true;
        }
        return this._debugMode;
    };
    Workunit.prototype.isRunning = function () {
        switch (this.StateID) {
            case WUStateID$1.Compiled:
            case WUStateID$1.Running:
            case WUStateID$1.Aborting:
            case WUStateID$1.Blocked:
            case WUStateID$1.DebugPaused:
            case WUStateID$1.DebugRunning:
                return true;
        }
        return false;
    };
    Workunit.prototype.setToFailed = function () {
        return this.WUAction("SetToFailed");
    };
    Workunit.prototype.pause = function () {
        return this.WUAction("Pause");
    };
    Workunit.prototype.pauseNow = function () {
        return this.WUAction("PauseNow");
    };
    Workunit.prototype.resume = function () {
        return this.WUAction("Resume");
    };
    Workunit.prototype.abort = function () {
        return this.WUAction("Abort");
    };
    Workunit.prototype.delete = function () {
        return this.WUAction("Delete");
    };
    Workunit.prototype.restore = function () {
        return this.WUAction("Restore");
    };
    Workunit.prototype.deschedule = function () {
        return this.WUAction("Deschedule");
    };
    Workunit.prototype.reschedule = function () {
        return this.WUAction("Reschedule");
    };
    Workunit.prototype.resubmit = function () {
        var _this = this;
        return this.WUResubmit({
            CloneWorkunit: false,
            ResetWorkflow: false
        }).then(function () {
            _this.clearState(_this.Wuid);
            return _this.refresh().then(function () {
                _this._monitor();
                return _this;
            });
        });
    };
    Workunit.prototype.clone = function () {
        var _this = this;
        return this.WUResubmit({
            CloneWorkunit: true,
            ResetWorkflow: false
        }).then(function (response) {
            return Workunit.attach(_this.connection.connection(), response.WUs.WU[0].WUID)
                .refresh();
        });
    };
    Workunit.prototype.refreshState = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.WUQuery()];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, this];
                }
            });
        });
    };
    Workunit.prototype.refreshInfo = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.WUInfo()];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, this];
                }
            });
        });
    };
    Workunit.prototype.refreshDebug = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.debugStatus()];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, this];
                }
            });
        });
    };
    Workunit.prototype.refresh = function (full) {
        if (full === void 0) { full = false; }
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!full) return [3 /*break*/, 2];
                        return [4 /*yield*/, Promise.all([this.refreshInfo(), this.refreshDebug()])];
                    case 1:
                        _a.sent();
                        return [3 /*break*/, 4];
                    case 2: return [4 /*yield*/, this.refreshState()];
                    case 3:
                        _a.sent();
                        _a.label = 4;
                    case 4: return [2 /*return*/, this];
                }
            });
        });
    };
    Workunit.prototype.eclExceptions = function () {
        return this.Exceptions.ECLException;
    };
    Workunit.prototype.fetchArchive = function () {
        return this.connection.WUFile({
            Wuid: this.Wuid,
            Type: "ArchiveQuery"
        });
    };
    Workunit.prototype.fetchECLExceptions = function () {
        var _this = this;
        return this.WUInfo({ IncludeExceptions: true }).then(function () {
            return _this.eclExceptions();
        });
    };
    Workunit.prototype.fetchResults = function () {
        var _this = this;
        return this.WUInfo({ IncludeResults: true }).then(function () {
            return _this.CResults;
        });
    };
    Workunit.prototype.fetchGraphs = function () {
        var _this = this;
        return this.WUInfo({ IncludeGraphs: true }).then(function () {
            return _this.CGraphs;
        });
    };
    Workunit.prototype.fetchDetailsMeta = function (request) {
        if (request === void 0) { request = {}; }
        return this.WUDetailsMeta(request);
    };
    Workunit.prototype.fetchDetailsRaw = function (request) {
        if (request === void 0) { request = {}; }
        return this.WUDetails(request).then(function (response) { return response.Scopes.Scope; });
    };
    Workunit.prototype.fetchDetailsNormalized = function (request) {
        if (request === void 0) { request = {}; }
        return Promise.all([this.fetchDetailsMeta(), this.fetchDetailsRaw(request)]).then(function (promises) {
            var meta = promises[0];
            var scopes = promises[1];
            var columns = {
                id: {
                    Measure: "label"
                },
                name: {
                    Measure: "label"
                },
                type: {
                    Measure: "label"
                }
            };
            var data = [];
            for (var _i = 0, scopes_1 = scopes; _i < scopes_1.length; _i++) {
                var scope = scopes_1[_i];
                var props = {};
                if (scope && scope.Id && scope.Properties && scope.Properties.Property) {
                    for (var key in scope.Properties.Property) {
                        var scopeProperty = scope.Properties.Property[key];
                        if (scopeProperty.Measure === "ns") {
                            scopeProperty.Measure = "s";
                        }
                        columns[scopeProperty.Name] = __assign({}, scopeProperty);
                        delete columns[scopeProperty.Name].RawValue;
                        delete columns[scopeProperty.Name].Formatted;
                        switch (scopeProperty.Measure) {
                            case "bool":
                                props[scopeProperty.Name] = !!+scopeProperty.RawValue;
                                break;
                            case "sz":
                                props[scopeProperty.Name] = +scopeProperty.RawValue;
                                break;
                            case "s":
                                props[scopeProperty.Name] = +scopeProperty.RawValue / 1000000000;
                                break;
                            case "ns":
                                props[scopeProperty.Name] = +scopeProperty.RawValue;
                                break;
                            case "ts":
                                props[scopeProperty.Name] = new Date(+scopeProperty.RawValue / 1000).toISOString();
                                break;
                            case "cnt":
                                props[scopeProperty.Name] = +scopeProperty.RawValue;
                                break;
                            case "cpu":
                            case "skw":
                            case "node":
                            case "ppm":
                            case "ip":
                            case "cy":
                            case "en":
                            case "txt":
                            case "id":
                            case "fname":
                            default:
                                props[scopeProperty.Name] = scopeProperty.RawValue;
                        }
                    }
                    data.push(__assign({ id: scope.Id, name: scope.ScopeName, type: scope.ScopeType }, props));
                }
            }
            return {
                meta: meta,
                columns: columns,
                data: data
            };
        });
    };
    Workunit.prototype.fetchDetails = function (request) {
        var _this = this;
        if (request === void 0) { request = {}; }
        return this.WUDetails(request).then(function (response) {
            return response.Scopes.Scope.map(function (rawScope) {
                return new Scope(_this, rawScope);
            });
        });
    };
    Workunit.prototype.fetchDetailsHierarchy = function (request) {
        var _this = this;
        if (request === void 0) { request = {}; }
        return this.WUDetails(request).then(function (response) {
            var retVal = [];
            //  Recreate Scope Hierarchy and dedup  ---
            var scopeMap = {};
            response.Scopes.Scope.forEach(function (rawScope) {
                if (scopeMap[rawScope.ScopeName]) {
                    scopeMap[rawScope.ScopeName].update(rawScope);
                    return null;
                }
                else {
                    var scope = new Scope(_this, rawScope);
                    scopeMap[scope.ScopeName] = scope;
                    return scope;
                }
            });
            for (var key in scopeMap) {
                if (scopeMap.hasOwnProperty(key)) {
                    var scope = scopeMap[key];
                    var parentScopeID = scope.parentScope();
                    if (parentScopeID && scopeMap[parentScopeID]) {
                        scopeMap[parentScopeID].children().push(scope);
                    }
                    else {
                        retVal.push(scope);
                    }
                }
            }
            return retVal;
        });
    };
    Workunit.prototype.fetchGraphDetails = function (graphIDs, rootTypes) {
        if (graphIDs === void 0) { graphIDs = []; }
        return this.fetchDetails({
            ScopeFilter: {
                MaxDepth: 999999,
                Ids: graphIDs,
                ScopeTypes: rootTypes
            },
            NestedFilter: {
                Depth: 999999,
                ScopeTypes: ["graph", "subgraph", "activity", "edge"]
            },
            PropertiesToReturn: {
                AllStatistics: true,
                AllAttributes: true,
                AllHints: true,
                AllProperties: true,
                AllScopes: true
            },
            ScopeOptions: {
                IncludeId: true,
                IncludeScope: true,
                IncludeScopeType: true
            },
            PropertyOptions: {
                IncludeName: true,
                IncludeRawValue: true,
                IncludeFormatted: true,
                IncludeMeasure: true,
                IncludeCreator: false,
                IncludeCreatorType: false
            }
        });
    };
    Workunit.prototype.fetchScopeGraphs = function (graphIDs) {
        if (graphIDs === void 0) { graphIDs = []; }
        return this.fetchGraphDetails(graphIDs, ["graph"]).then(function (scopes) {
            return createGraph(scopes);
        });
    };
    Workunit.prototype.fetchTimeElapsed = function () {
        return this.fetchDetails({
            ScopeFilter: {
                PropertyFilters: {
                    PropertyFilter: [{ Name: "TimeElapsed" }]
                }
            }
        }).then(function (scopes) {
            var scopeInfo = {};
            scopes.forEach(function (scope) {
                scopeInfo[scope.ScopeName] = scopeInfo[scope.ScopeName] || {
                    scope: scope.ScopeName,
                    start: null,
                    elapsed: null,
                    finish: null
                };
                scope.CAttributes.forEach(function (attr) {
                    if (attr.Name === "TimeElapsed") {
                        scopeInfo[scope.ScopeName].elapsed = +attr.RawValue;
                    }
                    else if (attr.Measure === "ts" && attr.Name.indexOf("Started") >= 0) {
                        scopeInfo[scope.ScopeName].start = attr.Formatted;
                    }
                });
            });
            // Workaround duplicate scope responses
            var retVal = [];
            for (var key in scopeInfo) {
                var scope = scopeInfo[key];
                if (scope.start && scope.elapsed) {
                    var endTime = parser(scope.start);
                    endTime.setMilliseconds(endTime.getMilliseconds() + scope.elapsed / 1000000);
                    scope.finish = formatter(endTime);
                    retVal.push(scope);
                }
            }
            retVal.sort(function (l, r) {
                if (l.start < r.start)
                    return -1;
                if (l.start > r.start)
                    return 1;
                return 0;
            });
            return retVal;
        });
    };
    //  Monitoring  ---
    Workunit.prototype._monitor = function () {
        if (this.isComplete()) {
            this._monitorTickCount = 0;
            return;
        }
        _super.prototype._monitor.call(this);
    };
    Workunit.prototype._monitorTimeoutDuraction = function () {
        var retVal = _super.prototype._monitorTimeoutDuraction.call(this);
        if (this._monitorTickCount <= 1) { //  Once
            return 1000;
        }
        else if (this._monitorTickCount <= 3) { //  Twice
            return 3000;
        }
        else if (this._monitorTickCount <= 5) { //  Twice
            return 5000;
        }
        else if (this._monitorTickCount <= 7) { //  Twice
            return 10000;
        }
        return retVal;
    };
    //  Events  ---
    Workunit.prototype.on = function (eventID, propIDorCallback, callback) {
        var _this = this;
        if (this.isCallback(propIDorCallback)) {
            switch (eventID) {
                case "completed":
                    _super.prototype.on.call(this, "propChanged", "StateID", function (changeInfo) {
                        if (_this.isComplete()) {
                            propIDorCallback([changeInfo]);
                        }
                    });
                    break;
                case "changed":
                    _super.prototype.on.call(this, eventID, propIDorCallback);
                    break;
            }
        }
        else {
            switch (eventID) {
                case "changed":
                    _super.prototype.on.call(this, eventID, propIDorCallback, callback);
                    break;
            }
        }
        this._monitor();
        return this;
    };
    Workunit.prototype.watchUntilComplete = function (callback) {
        var _this = this;
        return new Promise(function (resolve, _) {
            var watchHandle = _this.watch(function (changes) {
                if (callback) {
                    callback(changes);
                }
                if (_this.isComplete()) {
                    watchHandle.release();
                    resolve(_this);
                }
            });
        });
    };
    Workunit.prototype.watchUntilRunning = function (callback) {
        var _this = this;
        return new Promise(function (resolve, _) {
            var watchHandle = _this.watch(function (changes) {
                if (callback) {
                    callback(changes);
                }
                if (_this.isComplete() || _this.isRunning()) {
                    watchHandle.release();
                    resolve(_this);
                }
            });
        });
    };
    //  WsWorkunits passthroughs  ---
    Workunit.prototype.WUQuery = function (_request) {
        var _this = this;
        if (_request === void 0) { _request = {}; }
        return this.connection.WUQuery(__assign(__assign({}, _request), { Wuid: this.Wuid })).then(function (response) {
            _this.set(response.Workunits.ECLWorkunit[0]);
            return response;
        }).catch(function (e) {
            //  deleted  ---
            var wuMissing = e.Exception.some(function (exception) {
                if (exception.Code === 20081) {
                    _this.clearState(_this.Wuid);
                    _this.set("StateID", WUStateID$1.NotFound);
                    return true;
                }
                return false;
            });
            if (!wuMissing) {
                logger$1.warning("Unexpected exception:  ");
                throw e;
            }
            return {};
        });
    };
    Workunit.prototype.WUCreate = function () {
        var _this = this;
        return this.connection.WUCreate().then(function (response) {
            _this.set(response.Workunit);
            _workunits.set(_this);
            return response;
        });
    };
    Workunit.prototype.WUInfo = function (_request) {
        var _this = this;
        if (_request === void 0) { _request = {}; }
        var includeResults = _request.IncludeResults || _request.IncludeResultsViewNames;
        return this.connection.WUInfo(__assign(__assign({}, _request), { Wuid: this.Wuid, IncludeResults: includeResults, IncludeResultsViewNames: includeResults, SuppressResultSchemas: false })).then(function (response) {
            _this.set(response.Workunit);
            if (includeResults) {
                _this.set({
                    ResultViews: response.ResultViews
                });
            }
            return response;
        }).catch(function (e) {
            //  deleted  ---
            var wuMissing = e.Exception.some(function (exception) {
                if (exception.Code === 20080) {
                    _this.clearState(_this.Wuid);
                    _this.set("StateID", WUStateID$1.NotFound);
                    return true;
                }
                return false;
            });
            if (!wuMissing) {
                logger$1.warning("Unexpected exception:  ");
                throw e;
            }
            return {};
        });
    };
    Workunit.prototype.WUResubmit = function (request) {
        return this.connection.WUResubmit(deepMixinT({}, request, {
            Wuids: [this.Wuid]
        }));
    };
    Workunit.prototype.WUDetailsMeta = function (request) {
        return this.connection.WUDetailsMeta(request);
    };
    Workunit.prototype.WUDetails = function (request) {
        return this.connection.WUDetails(deepMixinT({
            ScopeFilter: {
                MaxDepth: 9999
            },
            ScopeOptions: {
                IncludeMatchedScopesInResults: true,
                IncludeScope: true,
                IncludeId: false,
                IncludeScopeType: false
            },
            PropertyOptions: {
                IncludeName: true,
                IncludeRawValue: false,
                IncludeFormatted: true,
                IncludeMeasure: true,
                IncludeCreator: false,
                IncludeCreatorType: false
            }
        }, request, { WUID: this.Wuid })).then(function (response) {
            return deepMixinT({
                Scopes: {
                    Scope: []
                }
            }, response);
        });
    };
    Workunit.prototype.WUAction = function (actionType) {
        var _this = this;
        return this.connection.WUAction({
            Wuids: [this.Wuid],
            WUActionType: actionType
        }).then(function (response) {
            return _this.refresh().then(function () {
                _this._monitor();
                return response;
            });
        });
    };
    Workunit.prototype.publish = function (name) {
        return this.connection.WUPublishWorkunit({
            Wuid: this.Wuid,
            Cluster: this.Cluster,
            JobName: name || this.Jobname,
            AllowForeignFiles: true,
            Activate: true,
            Wait: 5000
        });
    };
    Workunit.prototype.WUCDebug = function (command, opts) {
        if (opts === void 0) { opts = {}; }
        var optsStr = "";
        for (var key in opts) {
            if (opts.hasOwnProperty(key)) {
                optsStr += " " + key + "='" + opts[key] + "'";
            }
        }
        return this.connection.WUCDebug({
            Wuid: this.Wuid,
            Command: "<debug:" + command + " uid='" + this.Wuid + "'" + optsStr + "/>"
        }).then(function (response) {
            return response;
        });
    };
    Workunit.prototype.debug = function (command, opts) {
        if (!this.isDebugging()) {
            return Promise.resolve(new XMLNode(command));
        }
        return this.WUCDebug(command, opts).then(function (response) {
            var retVal = response.children(command);
            if (retVal.length) {
                return retVal[0];
            }
            return new XMLNode(command);
        }).catch(function (_) {
            logger$1.error(_);
            return Promise.resolve(new XMLNode(command));
        });
    };
    Workunit.prototype.debugStatus = function () {
        var _this = this;
        if (!this.isDebugging()) {
            return Promise.resolve({
                DebugState: { state: "unknown" }
            });
        }
        return this.debug("status").then(function (response) {
            var debugState = __assign(__assign({}, _this.DebugState), response.$);
            _this.set({
                DebugState: debugState
            });
            return response;
        });
    };
    Workunit.prototype.debugContinue = function (mode) {
        if (mode === void 0) { mode = ""; }
        return this.debug("continue", {
            mode: mode
        });
    };
    Workunit.prototype.debugStep = function (mode) {
        return this.debug("step", {
            mode: mode
        });
    };
    Workunit.prototype.debugPause = function () {
        return this.debug("interrupt");
    };
    Workunit.prototype.debugQuit = function () {
        return this.debug("quit");
    };
    Workunit.prototype.debugDeleteAllBreakpoints = function () {
        return this.debug("delete", {
            idx: 0
        });
    };
    Workunit.prototype.debugBreakpointResponseParser = function (rootNode) {
        return rootNode.children().map(function (childNode) {
            if (childNode.name === "break") {
                return childNode.$;
            }
        });
    };
    Workunit.prototype.debugBreakpointAdd = function (id, mode, action) {
        var _this = this;
        return this.debug("breakpoint", {
            id: id,
            mode: mode,
            action: action
        }).then(function (rootNode) {
            return _this.debugBreakpointResponseParser(rootNode);
        });
    };
    Workunit.prototype.debugBreakpointList = function () {
        var _this = this;
        return this.debug("list").then(function (rootNode) {
            return _this.debugBreakpointResponseParser(rootNode);
        });
    };
    Workunit.prototype.debugGraph = function () {
        var _this = this;
        if (this._debugAllGraph && this.DebugState["_prevGraphSequenceNum"] === this.DebugState["graphSequenceNum"]) {
            return Promise.resolve(this._debugAllGraph);
        }
        return this.debug("graph", { name: "all" }).then(function (response) {
            _this.DebugState["_prevGraphSequenceNum"] = _this.DebugState["graphSequenceNum"];
            _this._debugAllGraph = createXGMMLGraph(_this.Wuid, response);
            return _this._debugAllGraph;
        });
    };
    Workunit.prototype.debugBreakpointValid = function (path) {
        return this.debugGraph().then(function (graph) {
            return breakpointLocations(graph, path);
        });
    };
    Workunit.prototype.debugPrint = function (edgeID, startRow, numRows) {
        if (startRow === void 0) { startRow = 0; }
        if (numRows === void 0) { numRows = 10; }
        return this.debug("print", {
            edgeID: edgeID,
            startRow: startRow,
            numRows: numRows
        }).then(function (response) {
            return response.children().map(function (rowNode) {
                var retVal = {};
                rowNode.children().forEach(function (cellNode) {
                    retVal[cellNode.name] = cellNode.content;
                });
                return retVal;
            });
        });
    };
    return Workunit;
}(StateObject));
var ATTR_DEFINITION = "definition";
function hasECLDefinition(vertex) {
    return vertex._[ATTR_DEFINITION] !== undefined;
}
function getECLDefinition(vertex) {
    var match = /([a-z]:\\(?:[-\w\.\d]+\\)*(?:[-\w\.\d]+)?|(?:\/[\w\.\-]+)+)\((\d*),(\d*)\)/.exec(vertex._[ATTR_DEFINITION]);
    if (match) {
        var _file = match[1], _row = match[2], _col = match[3];
        _file.replace("/./", "/");
        return {
            id: vertex._["id"],
            file: _file,
            line: +_row,
            column: +_col
        };
    }
    throw new Error("Bad definition:  " + vertex._[ATTR_DEFINITION]);
}
function breakpointLocations(graph, path) {
    var retVal = [];
    for (var _i = 0, _a = graph.vertices; _i < _a.length; _i++) {
        var vertex = _a[_i];
        if (hasECLDefinition(vertex)) {
            var definition = getECLDefinition(vertex);
            if (definition && !path || path === definition.file) {
                retVal.push(definition);
            }
        }
    }
    return retVal.sort(function (l, r) {
        return l.line - r.line;
    });
}

var _activity;
var Activity = /** @class */ (function (_super) {
    __extends(Activity, _super);
    function Activity(optsConnection) {
        var _this = _super.call(this) || this;
        _this.lazyRefresh = debounce(function () { return __awaiter(_this, void 0, void 0, function () {
            var response;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.connection.Activity({})];
                    case 1:
                        response = _a.sent();
                        this.set(response);
                        return [2 /*return*/, this];
                }
            });
        }); });
        if (optsConnection instanceof SMCService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new SMCService(optsConnection);
        }
        _this.clear({});
        return _this;
    }
    Object.defineProperty(Activity.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "Exceptions", {
        get: function () { return this.get("Exceptions"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "Build", {
        get: function () { return this.get("Build"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "ThorClusterList", {
        get: function () { return this.get("ThorClusterList"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "RoxieClusterList", {
        get: function () { return this.get("RoxieClusterList"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "HThorClusterList", {
        get: function () { return this.get("HThorClusterList"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "DFUJobs", {
        get: function () { return this.get("DFUJobs"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "Running", {
        get: function () { return this.get("Running", { ActiveWorkunit: [] }); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "BannerContent", {
        get: function () { return this.get("BannerContent"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "BannerColor", {
        get: function () { return this.get("BannerColor"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "BannerSize", {
        get: function () { return this.get("BannerSize"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "BannerScroll", {
        get: function () { return this.get("BannerScroll"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "ChatURL", {
        get: function () { return this.get("ChatURL"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "ShowBanner", {
        get: function () { return this.get("ShowBanner"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "ShowChatURL", {
        get: function () { return this.get("ShowChatURL"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "SortBy", {
        get: function () { return this.get("SortBy"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "Descending", {
        get: function () { return this.get("Descending"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "SuperUser", {
        get: function () { return this.get("SuperUser"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "AccessRight", {
        get: function () { return this.get("AccessRight"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Activity.prototype, "ServerJobQueues", {
        get: function () { return this.get("ServerJobQueues"); },
        enumerable: false,
        configurable: true
    });
    Activity.attach = function (optsConnection, state) {
        if (!_activity) {
            _activity = new Activity(optsConnection);
        }
        if (state) {
            _activity.set(__assign({}, state));
        }
        return _activity;
    };
    Activity.prototype.runningWorkunits = function (clusterName) {
        var _this = this;
        if (clusterName === void 0) { clusterName = ""; }
        return this.Running.ActiveWorkunit.filter(function (awu) { return clusterName === "" || awu.ClusterName === clusterName; }).map(function (awu) { return Workunit.attach(_this.connection.connectionOptions(), awu.Wuid, awu); });
    };
    Activity.prototype.refresh = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/, this.lazyRefresh()];
            });
        });
    };
    return Activity;
}(StateObject));

var LogicalFileCache = /** @class */ (function (_super) {
    __extends(LogicalFileCache, _super);
    function LogicalFileCache() {
        return _super.call(this, function (obj) {
            return obj.BaseUrl + "-" + obj.Cluster + "-" + obj.Name;
        }) || this;
    }
    return LogicalFileCache;
}(Cache));
var _store = new LogicalFileCache();
var LogicalFile = /** @class */ (function (_super) {
    __extends(LogicalFile, _super);
    function LogicalFile(optsConnection, Cluster, Name) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof DFUService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new DFUService(optsConnection);
        }
        _this.clear({
            Cluster: Cluster,
            Name: Name
        });
        return _this;
    }
    Object.defineProperty(LogicalFile.prototype, "BaseUrl", {
        get: function () { return this.connection.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Cluster", {
        get: function () { return this.get("Cluster"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Filename", {
        get: function () { return this.get("Filename"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Prefix", {
        get: function () { return this.get("Prefix"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "NodeGroup", {
        get: function () { return this.get("NodeGroup"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "NumParts", {
        get: function () { return this.get("NumParts"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Description", {
        get: function () { return this.get("Description"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Dir", {
        get: function () { return this.get("Dir"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "PathMask", {
        get: function () { return this.get("PathMask"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Filesize", {
        get: function () { return this.get("Filesize"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "FileSizeInt64", {
        get: function () { return this.get("FileSizeInt64"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "RecordSize", {
        get: function () { return this.get("RecordSize"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "RecordCount", {
        get: function () { return this.get("RecordCount"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "RecordSizeInt64", {
        get: function () { return this.get("RecordSizeInt64"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "RecordCountInt64", {
        get: function () { return this.get("RecordCountInt64"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Wuid", {
        get: function () { return this.get("Wuid"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Owner", {
        get: function () { return this.get("Owner"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "JobName", {
        get: function () { return this.get("JobName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Persistent", {
        get: function () { return this.get("Persistent"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Format", {
        get: function () { return this.get("Format"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "MaxRecordSize", {
        get: function () { return this.get("MaxRecordSize"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "CsvSeparate", {
        get: function () { return this.get("CsvSeparate"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "CsvQuote", {
        get: function () { return this.get("CsvQuote"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "CsvTerminate", {
        get: function () { return this.get("CsvTerminate"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "CsvEscape", {
        get: function () { return this.get("CsvEscape"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Modified", {
        get: function () { return this.get("Modified"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Ecl", {
        get: function () { return this.get("Ecl"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Stat", {
        get: function () { return this.get("Stat"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "DFUFilePartsOnClusters", {
        get: function () { return this.get("DFUFilePartsOnClusters"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "isSuperfile", {
        get: function () { return this.get("isSuperfile"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "ShowFileContent", {
        get: function () { return this.get("ShowFileContent"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "subfiles", {
        get: function () { return this.get("subfiles"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Superfiles", {
        get: function () { return this.get("Superfiles"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "ProtectList", {
        get: function () { return this.get("ProtectList"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "FromRoxieCluster", {
        get: function () { return this.get("FromRoxieCluster"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Graphs", {
        get: function () { return this.get("Graphs"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "UserPermission", {
        get: function () { return this.get("UserPermission"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "ContentType", {
        get: function () { return this.get("ContentType"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "CompressedFileSize", {
        get: function () { return this.get("CompressedFileSize"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "PercentCompressed", {
        get: function () { return this.get("PercentCompressed"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "IsCompressed", {
        get: function () { return this.get("IsCompressed"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "BrowseData", {
        get: function () { return this.get("BrowseData"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "jsonInfo", {
        get: function () { return this.get("jsonInfo"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "binInfo", {
        get: function () { return this.get("binInfo"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "PackageID", {
        get: function () { return this.get("PackageID"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Partition", {
        get: function () { return this.get("Partition"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "Blooms", {
        get: function () { return this.get("Blooms"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "ExpireDays", {
        get: function () { return this.get("ExpireDays"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "KeyType", {
        get: function () { return this.get("KeyType"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(LogicalFile.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    LogicalFile.attach = function (optsConnection, Cluster, Name) {
        var retVal = _store.get({ BaseUrl: optsConnection.baseUrl, Cluster: Cluster, Name: Name }, function () {
            return new LogicalFile(optsConnection, Cluster, Name);
        });
        return retVal;
    };
    LogicalFile.prototype.fetchInfo = function () {
        var _this = this;
        return this.connection.DFUInfo({ Cluster: this.Cluster, Name: this.Name }).then(function (response) {
            _this.set(__assign({ Cluster: _this.Cluster }, response.FileDetail));
            return response.FileDetail;
        });
    };
    return LogicalFile;
}(StateObject));

var MachineCache = /** @class */ (function (_super) {
    __extends(MachineCache, _super);
    function MachineCache() {
        return _super.call(this, function (obj) {
            return obj.Address;
        }) || this;
    }
    return MachineCache;
}(Cache));
var _machines = new MachineCache();
var Machine = /** @class */ (function (_super) {
    __extends(Machine, _super);
    function Machine(optsConnection) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof MachineService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new MachineService(optsConnection);
        }
        return _this;
    }
    Object.defineProperty(Machine.prototype, "Address", {
        get: function () { return this.get("Address"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "ConfigAddress", {
        get: function () { return this.get("ConfigAddress"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "ProcessType", {
        get: function () { return this.get("ProcessType"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "DisplayType", {
        get: function () { return this.get("DisplayType"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Description", {
        get: function () { return this.get("Description"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "AgentVersion", {
        get: function () { return this.get("AgentVersion"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Contact", {
        get: function () { return this.get("Contact"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Location", {
        get: function () { return this.get("Location"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "UpTime", {
        get: function () { return this.get("UpTime"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "ComponentName", {
        get: function () { return this.get("ComponentName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "ComponentPath", {
        get: function () { return this.get("ComponentPath"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "RoxieState", {
        get: function () { return this.get("RoxieState"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "RoxieStateDetails", {
        get: function () { return this.get("RoxieStateDetails"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "OS", {
        get: function () { return this.get("OS"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "ProcessNumber", {
        get: function () { return this.get("ProcessNumber"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Processors", {
        get: function () { return this.get("Processors"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Storage", {
        get: function () { return this.get("Storage"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "Running", {
        get: function () { return this.get("Running"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "PhysicalMemory", {
        get: function () { return this.get("PhysicalMemory"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "VirtualMemory", {
        get: function () { return this.get("VirtualMemory"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Machine.prototype, "ComponentInfo", {
        get: function () { return this.get("ComponentInfo"); },
        enumerable: false,
        configurable: true
    });
    Machine.attach = function (optsConnection, address, state) {
        var retVal = _machines.get({ Address: address }, function () {
            return new Machine(optsConnection);
        });
        if (state) {
            retVal.set(state);
        }
        return retVal;
    };
    return Machine;
}(StateObject));

var QueryCache = /** @class */ (function (_super) {
    __extends(QueryCache, _super);
    function QueryCache() {
        return _super.call(this, function (obj) {
            return Cache.hash([obj.QueryId, obj.QuerySet]);
        }) || this;
    }
    return QueryCache;
}(Cache));
var _queries = new QueryCache();
var Query = /** @class */ (function (_super) {
    __extends(Query, _super);
    function Query(optsConnection, querySet, queryID, queryDetails) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof EclService) {
            _this.connection = optsConnection;
            // this._topology = new Topology(this.connection.opts());
        }
        else {
            _this.connection = new EclService(optsConnection);
            // this._topology = new Topology(optsConnection);
        }
        _this.set(__assign({ QuerySet: querySet, QueryId: queryID }, queryDetails));
        return _this;
    }
    Object.defineProperty(Query.prototype, "BaseUrl", {
        get: function () { return this.connection.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "properties", {
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Exceptions", {
        get: function () { return this.get("Exceptions"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "QueryId", {
        get: function () { return this.get("QueryId"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "QuerySet", {
        get: function () { return this.get("QuerySet"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "QueryName", {
        get: function () { return this.get("QueryName"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Wuid", {
        get: function () { return this.get("Wuid"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Dll", {
        get: function () { return this.get("Dll"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Suspended", {
        get: function () { return this.get("Suspended"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Activated", {
        get: function () { return this.get("Activated"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "SuspendedBy", {
        get: function () { return this.get("SuspendedBy"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Clusters", {
        get: function () { return this.get("Clusters"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "PublishedBy", {
        get: function () { return this.get("PublishedBy"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Comment", {
        get: function () { return this.get("Comment"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "LogicalFiles", {
        get: function () { return this.get("LogicalFiles"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "SuperFiles", {
        get: function () { return this.get("SuperFiles"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "IsLibrary", {
        get: function () { return this.get("IsLibrary"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "Priority", {
        get: function () { return this.get("Priority"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "WUSnapShot", {
        get: function () { return this.get("WUSnapShot"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "CompileTime", {
        get: function () { return this.get("CompileTime"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "LibrariesUsed", {
        get: function () { return this.get("LibrariesUsed"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "CountGraphs", {
        get: function () { return this.get("CountGraphs"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "ResourceURLCount", {
        get: function () { return this.get("ResourceURLCount"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "WsEclAddresses", {
        get: function () { return this.get("WsEclAddresses"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "WUGraphs", {
        get: function () { return this.get("WUGraphs"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Query.prototype, "WUTimers", {
        get: function () { return this.get("WUTimers"); },
        enumerable: false,
        configurable: true
    });
    Query.attach = function (optsConnection, querySet, queryId) {
        var retVal = _queries.get({ BaseUrl: optsConnection.baseUrl, QuerySet: querySet, QueryId: queryId }, function () {
            return new Query(optsConnection, querySet, queryId);
        });
        return retVal;
    };
    Query.prototype.fetchRequestSchema = function () {
        return __awaiter(this, void 0, void 0, function () {
            var _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        _a = this;
                        return [4 /*yield*/, this.connection.requestJson(this.QuerySet, this.QueryId)];
                    case 1:
                        _a._requestSchema = _b.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    Query.prototype.fetchResponseSchema = function () {
        return __awaiter(this, void 0, void 0, function () {
            var _a;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        _a = this;
                        return [4 /*yield*/, this.connection.responseJson(this.QuerySet, this.QueryId)];
                    case 1:
                        _a._responseSchema = _b.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    Query.prototype.fetchSchema = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, Promise.all([this.fetchRequestSchema(), this.fetchResponseSchema()])];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    Query.prototype.submit = function (request) {
        return this.connection.submit(this.QuerySet, this.QueryId, request).then(function (results) {
            for (var key in results) {
                results[key] = results[key].Row;
            }
            return results;
        });
    };
    Query.prototype.refresh = function () {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                return [2 /*return*/, this.fetchSchema().then(function (schema) { return _this; })];
            });
        });
    };
    Query.prototype.requestFields = function () {
        if (!this._requestSchema)
            return [];
        return this._requestSchema;
    };
    Query.prototype.responseFields = function () {
        if (!this._responseSchema)
            return {};
        return this._responseSchema;
    };
    Query.prototype.resultNames = function () {
        var retVal = [];
        for (var key in this.responseFields()) {
            retVal.push(key);
        }
        return retVal;
    };
    Query.prototype.resultFields = function (resultName) {
        if (!this._responseSchema[resultName])
            return [];
        return this._responseSchema[resultName];
    };
    return Query;
}(StateObject));

var StoreCache = /** @class */ (function (_super) {
    __extends(StoreCache, _super);
    function StoreCache() {
        return _super.call(this, function (obj) {
            return obj.BaseUrl + "-" + obj.Name + ":" + obj.UserSpecific + "-" + obj.Namespace;
        }) || this;
    }
    return StoreCache;
}(Cache));
var _store$1 = new StoreCache();
var ValueChangedMessage = /** @class */ (function (_super) {
    __extends(ValueChangedMessage, _super);
    function ValueChangedMessage(key, value, oldValue) {
        var _this = _super.call(this) || this;
        _this.key = key;
        _this.value = value;
        _this.oldValue = oldValue;
        return _this;
    }
    Object.defineProperty(ValueChangedMessage.prototype, "canConflate", {
        get: function () { return true; },
        enumerable: false,
        configurable: true
    });
    ValueChangedMessage.prototype.conflate = function (other) {
        if (this.key === other.key) {
            this.value = other.value;
            return true;
        }
        return false;
    };
    ValueChangedMessage.prototype.void = function () {
        return this.value === this.oldValue;
    };
    return ValueChangedMessage;
}(Message));
var Store = /** @class */ (function () {
    function Store(optsConnection, Name, Namespace, UserSpecific) {
        this._dispatch = new Dispatch();
        this._knownValues = {};
        if (optsConnection instanceof StoreService) {
            this.connection = optsConnection;
        }
        else {
            this.connection = new StoreService(optsConnection);
        }
        this.Name = Name;
        this.UserSpecific = UserSpecific;
        this.Namespace = Namespace;
    }
    Object.defineProperty(Store.prototype, "BaseUrl", {
        get: function () { return this.connection.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Store.attach = function (optsConnection, Name, Namespace, UserSpecific) {
        if (Name === void 0) { Name = "HPCCApps"; }
        if (UserSpecific === void 0) { UserSpecific = true; }
        var retVal = _store$1.get({ BaseUrl: optsConnection.baseUrl, Name: Name, UserSpecific: UserSpecific, Namespace: Namespace }, function () {
            return new Store(optsConnection, Name, Namespace, UserSpecific);
        });
        return retVal;
    };
    Store.prototype.create = function () {
        this.connection.CreateStore({ Name: this.Name, UserSpecific: this.UserSpecific, Type: "", Description: "" });
    };
    Store.prototype.set = function (key, value, broadcast) {
        var _this = this;
        if (broadcast === void 0) { broadcast = true; }
        return this.connection.Set({
            StoreName: this.Name,
            UserSpecific: this.UserSpecific,
            Namespace: this.Namespace,
            Key: key,
            Value: value
        }).then(function (response) {
            var oldValue = _this._knownValues[key];
            _this._knownValues[key] = value;
            if (broadcast) {
                _this._dispatch.post(new ValueChangedMessage(key, value, oldValue));
            }
        }).catch(function (e) {
            console.error("Store.set(\"" + key + "\", \"" + value + "\") failed:", e);
        });
    };
    Store.prototype.get = function (key, broadcast) {
        var _this = this;
        if (broadcast === void 0) { broadcast = true; }
        return this.connection.Fetch({
            StoreName: this.Name,
            UserSpecific: this.UserSpecific,
            Namespace: this.Namespace,
            Key: key
        }).then(function (response) {
            var oldValue = _this._knownValues[key];
            _this._knownValues[key] = response.Value;
            if (broadcast) {
                _this._dispatch.post(new ValueChangedMessage(key, response.Value, oldValue));
            }
            return response.Value;
        }).catch(function (e) {
            console.error("Store.get(" + key + ") failed:", e);
            return undefined;
        });
    };
    Store.prototype.getAll = function (broadcast) {
        var _this = this;
        if (broadcast === void 0) { broadcast = true; }
        return this.connection.FetchAll({
            StoreName: this.Name,
            UserSpecific: this.UserSpecific,
            Namespace: this.Namespace
        }).then(function (response) {
            var retVal = {};
            var deletedValues = _this._knownValues;
            _this._knownValues = {};
            response.Pairs.Pair.forEach(function (pair) {
                var oldValue = _this._knownValues[pair.Key];
                _this._knownValues[pair.Key] = pair.Value;
                delete deletedValues[pair.Key];
                retVal[pair.Key] = pair.Value;
                if (broadcast) {
                    _this._dispatch.post(new ValueChangedMessage(pair.Key, pair.Value, oldValue));
                }
            });
            if (broadcast) {
                for (var key in deletedValues) {
                    _this._dispatch.post(new ValueChangedMessage(key, undefined, deletedValues[key]));
                }
            }
            return retVal;
        }).catch(function (e) {
            console.error("Store.getAll failed:", e);
            return {};
        });
    };
    Store.prototype.delete = function (key, broadcast) {
        var _this = this;
        if (broadcast === void 0) { broadcast = true; }
        return this.connection.Delete({
            StoreName: this.Name,
            UserSpecific: this.UserSpecific,
            Namespace: this.Namespace,
            Key: key
        }).then(function (response) {
            var oldValue = _this._knownValues[key];
            delete _this._knownValues[key];
            if (broadcast) {
                _this._dispatch.post(new ValueChangedMessage(key, undefined, oldValue));
            }
        }).catch(function (e) {
            console.error("Store.delete(" + key + ") failed:", e);
        });
    };
    Store.prototype.monitor = function (callback) {
        return this._dispatch.attach(callback);
    };
    return Store;
}());

var TargetClusterCache = /** @class */ (function (_super) {
    __extends(TargetClusterCache, _super);
    function TargetClusterCache() {
        return _super.call(this, function (obj) {
            return obj.BaseUrl + "-" + obj.Name;
        }) || this;
    }
    return TargetClusterCache;
}(Cache));
var _targetCluster = new TargetClusterCache();
var TargetCluster = /** @class */ (function (_super) {
    __extends(TargetCluster, _super);
    function TargetCluster(optsConnection, name) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof TopologyService) {
            _this.connection = optsConnection;
            _this.machineConnection = new MachineService(optsConnection.connectionOptions());
        }
        else {
            _this.connection = new TopologyService(optsConnection);
            _this.machineConnection = new MachineService(optsConnection);
        }
        _this.clear({
            Name: name
        });
        return _this;
    }
    Object.defineProperty(TargetCluster.prototype, "BaseUrl", {
        get: function () { return this.connection.baseUrl; },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "Name", {
        get: function () { return this.get("Name"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "Prefix", {
        get: function () { return this.get("Prefix"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "Type", {
        get: function () { return this.get("Type"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "IsDefault", {
        get: function () { return this.get("IsDefault"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "TpClusters", {
        get: function () { return this.get("TpClusters"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "TpEclCCServers", {
        get: function () { return this.get("TpEclCCServers"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "TpEclServers", {
        get: function () { return this.get("TpEclServers"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "TpEclAgents", {
        get: function () { return this.get("TpEclAgents"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "TpEclSchedulers", {
        get: function () { return this.get("TpEclSchedulers"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "MachineInfoEx", {
        get: function () { return this.get("MachineInfoEx", []); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(TargetCluster.prototype, "CMachineInfoEx", {
        get: function () {
            var _this = this;
            return this.MachineInfoEx.map(function (machineInfoEx) { return Machine.attach(_this.machineConnection, machineInfoEx.Address, machineInfoEx); });
        },
        enumerable: false,
        configurable: true
    });
    TargetCluster.attach = function (optsConnection, name, state) {
        var retVal = _targetCluster.get({ BaseUrl: optsConnection.baseUrl, Name: name }, function () {
            return new TargetCluster(optsConnection, name);
        });
        if (state) {
            retVal.set(__assign({}, state));
        }
        return retVal;
    };
    TargetCluster.prototype.fetchMachines = function (request) {
        var _this = this;
        if (request === void 0) { request = {}; }
        return this.machineConnection.GetTargetClusterInfo(__assign({ TargetClusters: {
                Item: [this.Type + ":" + this.Name]
            } }, request)).then(function (response) {
            var retVal = [];
            for (var _i = 0, _a = response.TargetClusterInfoList.TargetClusterInfo; _i < _a.length; _i++) {
                var machineInfo = _a[_i];
                for (var _b = 0, _c = machineInfo.Processes.MachineInfoEx; _b < _c.length; _b++) {
                    var machineInfoEx = _c[_b];
                    retVal.push(machineInfoEx);
                }
            }
            _this.set("MachineInfoEx", retVal);
            return _this.CMachineInfoEx;
        });
    };
    TargetCluster.prototype.machineStats = function () {
        var maxDisk = 0;
        var totalFree = 0;
        var total = 0;
        for (var _i = 0, _a = this.CMachineInfoEx; _i < _a.length; _i++) {
            var machine = _a[_i];
            for (var _b = 0, _c = machine.Storage.StorageInfo; _b < _c.length; _b++) {
                var storageInfo = _c[_b];
                totalFree += storageInfo.Available;
                total += storageInfo.Total;
                var usage = 1 - storageInfo.Available / storageInfo.Total;
                if (usage > maxDisk) {
                    maxDisk = usage;
                }
            }
        }
        return {
            maxDisk: maxDisk,
            meanDisk: 1 - (total ? totalFree / total : 1)
        };
    };
    TargetCluster.prototype.fetchUsage = function () {
        return this.machineConnection.GetTargetClusterUsageEx([this.Name]);
    };
    return TargetCluster;
}(StateObject));
function targetClusters(optsConnection) {
    var connection;
    if (optsConnection instanceof TopologyService) {
        connection = optsConnection;
    }
    else {
        connection = new TopologyService(optsConnection);
    }
    return connection.TpListTargetClusters({}).then(function (response) {
        return response.TargetClusters.TpClusterNameType.map(function (item) { return TargetCluster.attach(optsConnection, item.Name, item); });
    });
}
var _defaultTargetCluster = {};
function defaultTargetCluster(optsConnection) {
    if (!_defaultTargetCluster[optsConnection.baseUrl]) {
        var connection = void 0;
        if (optsConnection instanceof TopologyService) {
            connection = optsConnection;
        }
        else {
            connection = new TopologyService(optsConnection);
        }
        _defaultTargetCluster[optsConnection.baseUrl] = connection.TpListTargetClusters({}).then(function (response) {
            var firstItem;
            var defaultItem;
            var hthorItem;
            response.TargetClusters.TpClusterNameType.forEach(function (item) {
                if (!firstItem) {
                    firstItem = item;
                }
                if (!defaultItem && item.IsDefault === true) {
                    defaultItem = item;
                }
                if (!hthorItem && item.Type === "hthor") {
                    hthorItem = item;
                }
            });
            var defItem = defaultItem || hthorItem || firstItem;
            return TargetCluster.attach(optsConnection, defItem.Name, defItem);
        });
    }
    return _defaultTargetCluster[optsConnection.baseUrl];
}

var Topology = /** @class */ (function (_super) {
    __extends(Topology, _super);
    function Topology(optsConnection) {
        var _this = _super.call(this) || this;
        if (optsConnection instanceof TopologyService) {
            _this.connection = optsConnection;
        }
        else {
            _this.connection = new TopologyService(optsConnection);
        }
        return _this;
    }
    Object.defineProperty(Topology.prototype, "properties", {
        //  Accessors  ---
        get: function () { return this.get(); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Topology.prototype, "TargetClusters", {
        get: function () { return this.get("TargetClusters"); },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Topology.prototype, "CTargetClusters", {
        get: function () {
            var _this = this;
            return this.TargetClusters.map(function (tc) { return TargetCluster.attach(_this.connection, tc.Name, tc); });
        },
        enumerable: false,
        configurable: true
    });
    Topology.prototype.GetESPServiceBaseURL = function (type) {
        var _this = this;
        if (type === void 0) { type = ""; }
        return this.connection.TpServiceQuery({}).then(function (response) {
            var rootProtocol = _this.connection.protocol();
            var ip = _this.connection.ip();
            var port = rootProtocol === "https:" ? "18002" : "8002";
            if (exists("ServiceList.TpEspServers.TpEspServer", response)) {
                for (var _i = 0, _a = response.ServiceList.TpEspServers.TpEspServer; _i < _a.length; _i++) {
                    var item = _a[_i];
                    if (exists("TpBindings.TpBinding", item)) {
                        for (var _b = 0, _c = item.TpBindings.TpBinding; _b < _c.length; _b++) {
                            var binding = _c[_b];
                            if (binding.Service === type && binding.Protocol + ":" === rootProtocol) {
                                port = binding.Port;
                            }
                        }
                    }
                }
            }
            return rootProtocol + "//" + ip + ":" + port + "/";
        });
    };
    Topology.prototype.fetchTargetClusters = function () {
        var _this = this;
        return this.connection.TpTargetClusterQuery({ Type: "ROOT" }).then(function (response) {
            _this.set({
                TargetClusters: response.TpTargetClusters.TpTargetCluster
            });
            return _this.CTargetClusters;
        });
    };
    Topology.prototype.refresh = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.fetchTargetClusters()];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, this];
                }
            });
        });
    };
    //  Monitoring  ---
    //  Events  ---
    Topology.prototype.on = function (eventID, propIDorCallback, callback) {
        if (this.isCallback(propIDorCallback)) {
            switch (eventID) {
                case "changed":
                    _super.prototype.on.call(this, eventID, propIDorCallback);
                    break;
            }
        }
        else {
            switch (eventID) {
                case "changed":
                    _super.prototype.on.call(this, eventID, propIDorCallback, callback);
                    break;
            }
        }
        this._monitor();
        return this;
    };
    return Topology;
}(StateObject));

var logger$2 = scopedLogger("clienttools/eclmeta");
var Attr = /** @class */ (function () {
    function Attr(xmlAttr) {
        this.__attrs = xmlAttr.$;
        this.name = xmlAttr.$.name;
    }
    return Attr;
}());
var Field = /** @class */ (function () {
    function Field(definition, xmlField) {
        this.__attrs = xmlField.$;
        this.definition = definition;
        this.name = xmlField.$.name;
        this.type = xmlField.$.type;
    }
    Object.defineProperty(Field.prototype, "scope", {
        get: function () {
            return this.definition;
        },
        enumerable: false,
        configurable: true
    });
    return Field;
}());
var ECLScope = /** @class */ (function () {
    function ECLScope(name, type, sourcePath, xmlDefinitions, line, start, body, end) {
        if (line === void 0) { line = 1; }
        if (start === void 0) { start = 0; }
        if (body === void 0) { body = 0; }
        if (end === void 0) { end = Number.MAX_VALUE; }
        this.name = name;
        this.type = type;
        this.sourcePath = normalize(sourcePath);
        this.line = +line - 1;
        this.start = +start;
        this.body = +body;
        this.end = +end;
        this.definitions = this.parseDefinitions(xmlDefinitions);
    }
    Object.defineProperty(ECLScope.prototype, "scope", {
        get: function () {
            return this;
        },
        enumerable: false,
        configurable: true
    });
    ECLScope.prototype.parseDefinitions = function (definitions) {
        var _this = this;
        if (definitions === void 0) { definitions = []; }
        return definitions.map(function (definition) {
            var retVal = new Definition(_this.sourcePath, definition);
            return retVal;
        });
    };
    ECLScope.prototype.contains = function (charOffset) {
        return charOffset >= this.start && charOffset <= this.end;
    };
    ECLScope.prototype.scopeStackAt = function (charOffset) {
        var retVal = [];
        if (this.contains(charOffset)) {
            retVal.push(this);
            this.definitions.forEach(function (def) {
                retVal = def.scopeStackAt(charOffset).concat(retVal);
            });
        }
        return retVal;
    };
    ECLScope.prototype._resolve = function (defs, qualifiedID) {
        if (defs === void 0) { defs = []; }
        var qualifiedIDParts = qualifiedID.split(".");
        var base = qualifiedIDParts.shift();
        var retVal = find(defs, function (def) {
            if (typeof def.name === "string" && typeof base === "string" && def.name.toLowerCase() === base.toLowerCase()) {
                return true;
            }
            return false;
        });
        if (retVal && retVal.definitions.length && qualifiedIDParts.length) {
            return this._resolve(retVal.definitions, qualifiedIDParts.join("."));
        }
        return retVal;
    };
    ECLScope.prototype.resolve = function (qualifiedID) {
        return this._resolve(this.definitions, qualifiedID);
    };
    ECLScope.prototype.suggestions = function () {
        var _this = this;
        return this.definitions.map(function (def) {
            return {
                name: def.name,
                type: _this.type
            };
        });
    };
    return ECLScope;
}());
var Definition = /** @class */ (function (_super) {
    __extends(Definition, _super);
    function Definition(sourcePath, xmlDefinition) {
        var _this = _super.call(this, xmlDefinition.$.name, xmlDefinition.$.type, sourcePath, xmlDefinition.children("Definition"), xmlDefinition.$.line, xmlDefinition.$.start, xmlDefinition.$.body, xmlDefinition.$.end) || this;
        _this.__attrs = xmlDefinition.$;
        _this.exported = !!xmlDefinition.$.exported;
        _this.shared = !!xmlDefinition.$.shared;
        _this.fullname = xmlDefinition.$.fullname;
        _this.inherittype = xmlDefinition.$.inherittype;
        _this.attrs = _this.parseAttrs(xmlDefinition.children("Attr"));
        _this.fields = _this.parseFields(xmlDefinition.children("Field"));
        return _this;
    }
    Definition.prototype.parseAttrs = function (attrs) {
        if (attrs === void 0) { attrs = []; }
        return attrs.map(function (attr) {
            var retVal = new Attr(attr);
            return retVal;
        });
    };
    Definition.prototype.parseFields = function (fields) {
        var _this = this;
        if (fields === void 0) { fields = []; }
        return fields.map(function (field) {
            var retVal = new Field(_this, field);
            return retVal;
        });
    };
    Definition.prototype.suggestions = function () {
        return _super.prototype.suggestions.call(this).concat(this.fields.map(function (field) {
            return {
                name: field.name,
                type: field.type
            };
        }));
    };
    return Definition;
}(ECLScope));
var Import = /** @class */ (function () {
    function Import(xmlImport) {
        this.__attrs = xmlImport.$;
        this.name = xmlImport.$.name;
        this.ref = xmlImport.$.ref;
        this.start = xmlImport.$.start;
        this.end = xmlImport.$.end;
        this.line = xmlImport.$.line;
    }
    return Import;
}());
var Source = /** @class */ (function (_super) {
    __extends(Source, _super);
    function Source(xmlSource) {
        var _this = _super.call(this, xmlSource.$.name, "source", xmlSource.$.sourcePath, xmlSource.children("Definition")) || this;
        _this.__attrs = xmlSource.$;
        var nameParts = xmlSource.$.name.split(".");
        nameParts.pop();
        var fakeNode = new XMLNode("");
        fakeNode.appendAttribute("name", "$");
        fakeNode.appendAttribute("ref", nameParts.join("."));
        _this.imports = __spreadArrays([
            new Import(fakeNode)
        ], _this.parseImports(xmlSource.children("Import")));
        return _this;
    }
    Source.prototype.parseImports = function (imports) {
        if (imports === void 0) { imports = []; }
        return imports.map(function (imp) {
            var retVal = new Import(imp);
            return retVal;
        });
    };
    Source.prototype.resolve = function (qualifiedID, charOffset) {
        var retVal;
        //  Check Inner Scopes  ---
        if (!retVal && charOffset !== undefined) {
            var scopes = this.scopeStackAt(charOffset);
            scopes.some(function (scope) {
                retVal = scope.resolve(qualifiedID);
                return !!retVal;
            });
        }
        //  Check Definitions  ---
        if (!retVal) {
            retVal = _super.prototype.resolve.call(this, qualifiedID);
        }
        return retVal;
    };
    return Source;
}(ECLScope));
var isHiddenDirectory = function (source) { return basename(source).indexOf(".") === 0; };
var isDirectory = function (source) { return lstatSync(source).isDirectory() && !isHiddenDirectory(source); };
var isEcl = function (source) { return [".ecl", ".ecllib"].indexOf(extname(source).toLowerCase()) >= 0; };
var modAttrs = function (source) { return readdirSync(source).map(function (name) { return join$1(source, name); }).filter(function (path) { return isDirectory(path) || isEcl(path); }); };
var File = /** @class */ (function (_super) {
    __extends(File, _super);
    function File(name, sourcePath) {
        return _super.call(this, name, "file", sourcePath, []) || this;
    }
    File.prototype.suggestions = function () {
        return [];
    };
    return File;
}(ECLScope));
var Folder = /** @class */ (function (_super) {
    __extends(Folder, _super);
    function Folder(name, sourcePath) {
        return _super.call(this, name, "folder", sourcePath, []) || this;
    }
    Folder.prototype.suggestions = function () {
        return modAttrs(this.sourcePath).map(function (folder) {
            return {
                name: basename(folder, ".ecl"),
                type: "folder"
            };
        });
    };
    return Folder;
}(ECLScope));
var Workspace = /** @class */ (function () {
    function Workspace(workspacePath, eclccPath) {
        this._sourceByID = new DictionaryNoCase();
        this._sourceByPath = new Dictionary();
        this._test = new DictionaryNoCase();
        this._workspacePath = workspacePath;
        this._eclccPath = eclccPath;
    }
    Workspace.prototype.refresh = function () {
        this.primeWorkspace();
        this.primeClientTools();
    };
    Workspace.prototype.primeClientTools = function () {
        var _this = this;
        return locateClientTools(this._eclccPath, "", this._workspacePath).then(function (clientTools) {
            _this._clientTools = clientTools;
            return clientTools.paths();
        }).then(function (paths) {
            for (var _i = 0, _a = ["ECLCC_ECLLIBRARY_PATH", "ECLCC_PLUGIN_PATH"]; _i < _a.length; _i++) {
                var knownFolder = _a[_i];
                if (paths[knownFolder] && existsSync(paths[knownFolder])) {
                    _this.walkChildFolders(paths[knownFolder], paths[knownFolder]);
                }
            }
            return _this;
        });
    };
    Workspace.prototype.primeWorkspace = function () {
        if (existsSync(this._workspacePath)) {
            this.visitFolder(this._workspacePath, this._workspacePath);
        }
    };
    Workspace.prototype.walkChildFolders = function (folderPath, refPath, force) {
        if (force === void 0) { force = false; }
        for (var _i = 0, _a = modAttrs(folderPath); _i < _a.length; _i++) {
            var child = _a[_i];
            if (!isDirectory(child)) {
                this.visitFile(child, refPath, force);
            }
            else {
                this.visitFolder(child, refPath, force);
            }
        }
    };
    Workspace.prototype.visitFile = function (filePath, refPath, force) {
        if (force === void 0) { force = false; }
        var filePathInfo = parse(filePath);
        var pathNoExt = join$1(filePathInfo.dir, filePathInfo.name);
        var name = relative(refPath, pathNoExt).split(sep).join(".");
        if (force || !this._test.has(name)) {
            this._test.set(name, new File("", filePath));
        }
    };
    Workspace.prototype.visitFolder = function (folderPath, refPath, force) {
        if (force === void 0) { force = false; }
        var name = relative(refPath, folderPath).split(sep).join(".");
        if (force || !this._test.has(name)) {
            this._test.set(name, new Folder(name, folderPath));
            this.walkChildFolders(folderPath, refPath, force);
        }
    };
    Workspace.prototype.buildStack = function (parentStack, name, removeDupID) {
        var nameStack = name.split(".");
        if (removeDupID && parentStack[parentStack.length - 1] === nameStack[0]) {
            nameStack.shift();
        }
        var stack = __spreadArrays(parentStack, nameStack);
        var qid = stack.join(".");
        return {
            stack: stack,
            qid: qid
        };
    };
    Workspace.prototype.walkECLScope = function (parentStack, scope) {
        var info = this.buildStack(parentStack, scope.name, true);
        this._test.set(info.qid, scope);
        for (var _i = 0, _a = scope.definitions; _i < _a.length; _i++) {
            var def = _a[_i];
            this.walkDefinition(info.stack, def);
        }
    };
    Workspace.prototype.walkField = function (parentStack, field) {
        var info = this.buildStack(parentStack, field.name, false);
        this._test.set(info.qid, field);
    };
    Workspace.prototype.walkDefinition = function (parentStack, definition) {
        var info = this.buildStack(parentStack, definition.name, true);
        this.walkECLScope(parentStack, definition);
        for (var _i = 0, _a = definition.fields; _i < _a.length; _i++) {
            var field = _a[_i];
            this.walkField(info.stack, field);
        }
    };
    Workspace.prototype.walkSource = function (source) {
        // const dirName = path.dirname(source.sourcePath);
        // const relName = path.relative(this._workspacePath, dirName).split(path.sep).join(".");
        // const folder = new Folder(relName, dirName);
        // this._test.set(folder.name, folder);
        this.walkECLScope([], source);
    };
    Workspace.prototype.parseSources = function (sources) {
        if (sources === void 0) { sources = []; }
        for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
            var _source = sources_1[_i];
            if (_source.$.name) { //  Plugins have no name...
                var source = new Source(_source);
                this._sourceByID.set(source.name, source);
                this._sourceByPath.set(source.sourcePath, source);
                //  If external source like "std.system.ThorLib" then need to backup to "std" and add its folder
                if (source.name) {
                    var sourceNameParts = source.name.split(".");
                    var depth = sourceNameParts.length;
                    if (depth > 1) {
                        var sourcePath = source.sourcePath;
                        while (depth > 1) {
                            sourcePath = dirname(sourcePath);
                            --depth;
                        }
                        this.visitFolder(sourcePath, dirname(sourcePath));
                    }
                }
                this.walkSource(source);
            }
        }
    };
    Workspace.prototype.parseMetaXML = function (metaXML) {
        var metaParser = new MetaParser();
        metaParser.parse(metaXML);
        this.parseSources(metaParser.sources);
        return metaParser.sources.map(function (source) { return normalize(source.$.sourcePath); });
    };
    Workspace.prototype.resolveQualifiedID = function (filePath, qualifiedID, charOffset) {
        var retVal;
        if (!retVal && this._test.has(qualifiedID)) {
            retVal = this._test.get(qualifiedID).scope;
        }
        if (!retVal && this._sourceByPath.has(filePath)) {
            var eclSource = this._sourceByPath.get(filePath);
            //  Resolve Imports  ---
            var qualifiedIDParts = qualifiedID.split(".");
            for (var _i = 0, _a = eclSource.imports; _i < _a.length; _i++) {
                var imp = _a[_i];
                if (imp.name.toLowerCase() === qualifiedIDParts[0].toLowerCase()) {
                    if (imp.ref) {
                        qualifiedIDParts[0] = imp.ref;
                    }
                    else {
                        qualifiedIDParts.shift();
                    }
                    break;
                }
            }
            var realQID = qualifiedIDParts.join(".");
            if (!retVal && this._test.has(realQID)) {
                retVal = this._test.get(realQID).scope;
            }
            if (!retVal) {
                realQID = __spreadArrays(eclSource.name.split("."), qualifiedIDParts).join(".");
                if (this._test.has(realQID)) {
                    retVal = this._test.get(realQID).scope;
                }
            }
        }
        return retVal;
    };
    Workspace.prototype.resolvePartialID = function (filePath, partialID, charOffset) {
        partialID = partialID.toLowerCase();
        var partialIDParts = partialID.split(".");
        partialIDParts.pop();
        var partialIDQualifier = partialIDParts.length === 1 ? partialIDParts[0] : partialIDParts.join(".");
        return this.resolveQualifiedID(filePath, partialIDQualifier, charOffset);
    };
    return Workspace;
}());
var workspaceCache = new Dictionary();
function attachWorkspace(_workspacePath, eclccPath) {
    var workspacePath = normalize(_workspacePath);
    if (!workspaceCache.has(workspacePath)) {
        var workspace = new Workspace(workspacePath, eclccPath);
        workspaceCache.set(workspacePath, workspace);
        workspace.refresh();
    }
    return workspaceCache.get(workspacePath);
}
function isQualifiedIDChar(lineText, charPos, reverse) {
    if (charPos < 0)
        return false;
    var testChar = lineText.charAt(charPos);
    return (reverse ? /[a-zA-Z\d_\.$]/ : /[a-zA-Z\d_]/).test(testChar);
}
function qualifiedIDBoundary(lineText, charPos, reverse) {
    while (isQualifiedIDChar(lineText, charPos, reverse)) {
        charPos += reverse ? -1 : 1;
    }
    return charPos + (reverse ? 1 : -1);
}
var MetaParser = /** @class */ (function (_super) {
    __extends(MetaParser, _super);
    function MetaParser() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.sources = [];
        return _this;
    }
    MetaParser.prototype.endXMLNode = function (e) {
        switch (e.name) {
            case "Source":
                this.sources.push(e);
                break;
        }
        _super.prototype.endXMLNode.call(this, e);
    };
    return MetaParser;
}(SAXStackParser));

var logger$3 = scopedLogger("clienttools/eclcc");
var exeExt = type() === "Windows_NT" ? ".exe" : "";
var Version = /** @class */ (function () {
    function Version(build) {
        this.prefix = "";
        this.major = 0;
        this.minor = 0;
        this.patch = 0;
        this.postfix = "";
        var parts = build.split(" ");
        if (parts.length) {
            var match = /(?:(\w+)_)?(\d+)\.(\d+)\.(\d+)(?:-(.*))?/.exec(parts[parts.length - 1]);
            if (match) {
                this.prefix = match[1] || "";
                this.major = +match[2] || 0;
                this.minor = +match[3] || 0;
                this.patch = +match[4] || 0;
                this.postfix = match[5] || "";
            }
        }
    }
    Version.prototype.parse = function (build) {
    };
    Version.prototype.exists = function () {
        return this.major !== 0 || this.minor !== 0 || this.patch !== 0 || this.postfix !== "";
    };
    Version.prototype.compare = function (other) {
        if (this.major > other.major)
            return 1;
        if (this.major < other.major)
            return -1;
        if (this.minor > other.minor)
            return 1;
        if (this.minor < other.minor)
            return -1;
        if (this.patch > other.patch)
            return 1;
        if (this.patch < other.patch)
            return -1;
        if (this.postfix === "" && other.postfix !== "")
            return 1;
        return this.postfix.localeCompare(other.postfix);
    };
    Version.prototype.toString = function () {
        return this.prefix + "_" + this.major + "." + this.minor + "." + this.patch + "-" + this.postfix;
    };
    return Version;
}());
var ERROR = "error";
var WARN = "warning";
var Errors = /** @class */ (function () {
    function Errors(checked) {
        this.errWarn = [];
        this.errOther = [];
        this._checked = checked;
    }
    Errors.prototype.checked = function () {
        return this._checked;
    };
    Errors.prototype.all = function () {
        return this.errWarn;
    };
    Errors.prototype.errors = function () {
        return this.errWarn.filter(function (e) { return e.severity === ERROR; });
    };
    Errors.prototype.hasError = function () {
        return this.errors().length > 0;
    };
    Errors.prototype.warnings = function () {
        return this.errWarn.filter(function (e) { return e.severity === WARN; });
    };
    Errors.prototype.hasWarning = function () {
        return this.warnings().length > 0;
    };
    Errors.prototype.info = function () {
        return this.errWarn.filter(function (e) { return [ERROR, WARN].indexOf(e.severity) < 0; });
    };
    Errors.prototype.hasOther = function () {
        return this.info().length > 0;
    };
    Errors.prototype.unknown = function () {
        return this.errOther;
    };
    Errors.prototype.hasUnknown = function () {
        return this.unknown().length > 0;
    };
    return Errors;
}());
var EclccErrors = /** @class */ (function (_super) {
    __extends(EclccErrors, _super);
    function EclccErrors(stdErr, checked) {
        var _this = _super.call(this, checked) || this;
        if (stdErr && stdErr.length) {
            for (var _i = 0, _a = stdErr.split(EOL); _i < _a.length; _i++) {
                var errLine = _a[_i];
                var match = /([a-zA-Z]:\\(?:[- \w\.\d]+\\)*(?:[- \w\.\d]+)?|(?:\/[\w\.\-]+)+)\((\d*),(\d*)\) ?: ?(error|warning|info) C(\d*) ?: ?(.*)/.exec(errLine);
                if (match) {
                    var filePath = match[1], row = match[2], _col = match[3], severity = match[4], code = match[5], _msg = match[6];
                    var line = +row;
                    var col = +_col;
                    var msg = code + ":  " + _msg;
                    _this.errWarn.push({ filePath: filePath, line: line, col: col, msg: msg, severity: severity });
                    continue;
                }
                match = /(error|warning|info): (.*)/i.exec(errLine);
                if (match) {
                    var severity = match[1], msg = match[2];
                    _this.errWarn.push({ filePath: "", line: 0, col: 0, msg: msg, severity: severity });
                    continue;
                }
                match = /\d error(s?), \d warning(s?)/.exec(errLine);
                if (match) {
                    continue;
                }
                logger$3.warning("parseECLErrors:  Unable to parse \"" + errLine + "\"");
                _this.errOther.push(errLine);
            }
        }
        _this._checked = checked;
        return _this;
    }
    return EclccErrors;
}(Errors));
var EnvchkErrors = /** @class */ (function (_super) {
    __extends(EnvchkErrors, _super);
    function EnvchkErrors(filePath, stdErr, checked) {
        var _this = _super.call(this, checked) || this;
        var content = readFileSync(filePath, "utf8");
        content = content.replace("\r\n", "\n");
        _this._lines = content.split("\n");
        if (stdErr && stdErr.length) {
            for (var _i = 0, _a = stdErr.split(EOL); _i < _a.length; _i++) {
                var errLine = _a[_i];
                var match = /(Warning|Error) : Path\=(\S*?)(\[\S*\])? Message\=(.*)/.exec(errLine);
                if (match) {
                    var severity = match[1], _path = match[2], _attr = match[3], _msg = match[4];
                    var msg = _path + " " + (_attr ? _attr : "") + ":  " + _msg;
                    var _b = _this.locate(_path), line = _b[0], col = _b[1];
                    _this.errWarn.push({ filePath: filePath, line: line, col: col, msg: msg, severity: severity });
                    continue;
                }
                if (match) {
                    continue;
                }
                logger$3.warning("parseECLErrors:  Unable to parse \"" + errLine + "\"");
                _this.errOther.push(errLine);
            }
        }
        _this._checked = checked;
        return _this;
    }
    EnvchkErrors.prototype.locate = function (path) {
        var pathParts = path.split("/");
        if (pathParts.length && pathParts[0] === "") {
            pathParts.shift();
        }
        if (pathParts.length > 0) {
            var lineIdx = 0;
            for (var _i = 0, _a = this._lines; _i < _a.length; _i++) {
                var line = _a[_i];
                var testStr = "<" + pathParts[0];
                if (line.indexOf(testStr + " ") >= 0 || line.indexOf(testStr + ">") >= 0) {
                    console.log(lineIdx, testStr);
                    pathParts.shift();
                    if (pathParts.length === 0) {
                        return [lineIdx + 1, line.indexOf(testStr) + 1];
                    }
                }
                ++lineIdx;
            }
        }
        return [0, 0];
    };
    return EnvchkErrors;
}(Errors));
function walkXmlJson$1(node, callback, stack) {
    stack = stack || [];
    stack.push(node);
    for (var key in node) {
        if (node.hasOwnProperty(key)) {
            var childNode = node[key];
            callback(key, childNode, stack);
            if (childNode instanceof Array) {
                childNode.forEach(function (child) {
                    walkXmlJson$1(child, callback, stack);
                });
            }
            else if (typeof childNode === "object") {
                walkXmlJson$1(childNode, callback, stack);
            }
        }
    }
    stack.pop();
}
var LocalWorkunit = /** @class */ (function () {
    function LocalWorkunit(jsonWU) {
        this.jsonWU = jsonWU;
    }
    LocalWorkunit.prototype.bpGetValidLocations = function (filePath) {
        var retVal = [];
        if (exists("W_LOCAL.Graphs", this.jsonWU)) {
            var id_1 = "";
            walkXmlJson$1(this.jsonWU.W_LOCAL.Graphs, function (key, item, _stack) {
                if (key === "$" && item.id) {
                    id_1 = item.id;
                }
                if (key === "$" && item.name === "definition") {
                    var match = /([a-z,A-Z]:\\(?:[-\w\.\d]+\\)*(?:[-\w\.\d]+)?|(?:\/[\w\.\-]+)+)\((\d*),(\d*)\)/.exec(item.value);
                    if (match) {
                        var file = match[1], row = match[2], _col = match[3];
                        var line = +row;
                        var col = +_col;
                        if (filePath === file) {
                            retVal.push({ file: file, line: line, col: col, id: id_1 });
                        }
                    }
                }
                // console.log(`${key}:  ` + JSON.stringify(item));
            });
        }
        return retVal;
    };
    return LocalWorkunit;
}());
var ClientTools = /** @class */ (function () {
    function ClientTools(eclccPath, cwd, includeFolders, legacyMode, args, version) {
        if (includeFolders === void 0) { includeFolders = []; }
        if (legacyMode === void 0) { legacyMode = false; }
        if (args === void 0) { args = []; }
        this._paths = {};
        this.eclccPath = eclccPath;
        this.binPath = dirname(this.eclccPath);
        this.envchkPath = join$1(this.binPath, "envchk" + exeExt);
        this.cwd = normalize(cwd || this.binPath);
        this.includeFolders = includeFolders;
        this._legacyMode = legacyMode;
        this._args = args;
        this._version = version;
    }
    ClientTools.prototype.clone = function (cwd, includeFolders, legacyMode, args) {
        if (legacyMode === void 0) { legacyMode = false; }
        if (args === void 0) { args = []; }
        return new ClientTools(this.eclccPath, cwd, includeFolders, legacyMode, args, this._version);
    };
    ClientTools.prototype.exists = function (filePath) {
        try {
            accessSync(filePath);
            return true;
        }
        catch (e) { }
        return false;
    };
    ClientTools.prototype.args = function (additionalItems) {
        if (additionalItems === void 0) { additionalItems = []; }
        var retVal = __spreadArrays(this._args);
        if (this._legacyMode) {
            retVal.push("-legacy");
        }
        return retVal.concat(this.includeFolders.map(function (includePath) {
            return "-I" + normalize(includePath);
        })).concat(additionalItems);
    };
    ClientTools.prototype.version = function () {
        var _this = this;
        if (this._version) {
            return Promise.resolve(this._version);
        }
        return this.execFile(this.eclccPath, this.binPath, this.args(["--version"]), "eclcc", "Cannot find " + this.eclccPath).then(function (response) {
            _this._version = new Version(response.stdout);
            return _this._version;
        });
    };
    ClientTools.prototype.versionSync = function () {
        return this._version;
    };
    ClientTools.prototype.paths = function () {
        var _this = this;
        return this.execFile(this.eclccPath, this.cwd, this.args(["-showpaths"]), "eclcc", "Cannot find " + this.eclccPath).then(function (response) {
            if (response && response.stdout && response.stdout.length) {
                var paths = response.stdout.split(/\r?\n/);
                for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
                    var path_1 = paths_1[_i];
                    var parts = path_1.split("=");
                    if (parts.length === 2) {
                        _this._paths[parts[0]] = parts[1];
                    }
                }
            }
            return _this._paths;
        });
    };
    ClientTools.prototype.loadXMLDoc = function (filePath, removeOnRead) {
        return new Promise(function (resolve, _reject) {
            var fileData = readFileSync(filePath, "ascii");
            var retVal = xml2json(fileData);
            if (removeOnRead) {
                unlink(filePath, function (err) { });
            }
            resolve(retVal);
        });
    };
    ClientTools.prototype.createWU = function (filename) {
        var _this = this;
        var tmpName = tmpNameSync({ prefix: "eclcc-wu-tmp", postfix: "" });
        var args = ["-o" + tmpName, "-wu"].concat([filename]);
        return this.execFile(this.eclccPath, this.cwd, this.args(args), "eclcc", "Cannot find " + this.eclccPath).then(function (_response) {
            var xmlPath = normalize(tmpName + ".xml");
            var contentPromise = _this.exists(xmlPath) ? _this.loadXMLDoc(xmlPath, true) : Promise.resolve({});
            return contentPromise.then(function (content) {
                return new LocalWorkunit(content);
            });
        });
    };
    ClientTools.prototype.createArchive = function (filename) {
        var args = ["-E"].concat([filename]);
        return this.execFile(this.eclccPath, this.cwd, this.args(args), "eclcc", "Cannot find " + this.eclccPath).then(function (response) {
            return {
                content: response.stdout,
                err: new EclccErrors(response.stderr, [])
            };
        });
    };
    ClientTools.prototype.attachWorkspace = function () {
        return attachWorkspace(this.cwd);
    };
    ClientTools.prototype.fetchMeta = function (filePath) {
        return Promise.all([
            attachWorkspace(this.cwd),
            this.execFile(this.eclccPath, this.cwd, this.args(["-M", filePath]), "eclcc", "Cannot find " + this.eclccPath)
        ]).then(function (_a) {
            var metaWorkspace = _a[0], execFileResponse = _a[1];
            if (execFileResponse && execFileResponse.stdout && execFileResponse.stdout.length) {
                metaWorkspace.parseMetaXML(execFileResponse.stdout);
            }
            return metaWorkspace;
        });
    };
    ClientTools.prototype.syntaxCheck = function (filePath, args) {
        if (args === void 0) { args = ["-syntax"]; }
        return Promise.all([
            attachWorkspace(this.cwd),
            this.execFile(this.eclccPath, this.cwd, this.args(__spreadArrays(args, ["-M", filePath])), "eclcc", "Cannot find " + this.eclccPath)
        ]).then(function (_a) {
            var metaWorkspace = _a[0], execFileResponse = _a[1];
            var checked = [];
            if (execFileResponse && execFileResponse.stdout && execFileResponse.stdout.length) {
                checked = metaWorkspace.parseMetaXML(execFileResponse.stdout);
            }
            return new EclccErrors(execFileResponse ? execFileResponse.stderr : "", checked);
        });
    };
    ClientTools.prototype.envCheck = function (filePath, args) {
        if (args === void 0) { args = []; }
        return Promise.all([
            attachWorkspace(this.cwd),
            this.execFile(this.envchkPath, this.cwd, this.args(__spreadArrays(args, [filePath])), "envchk", "Cannot find " + this.envchkPath)
        ]).then(function (_a) {
            var metaWorkspace = _a[0], execFileResponse = _a[1];
            return new EnvchkErrors(filePath, execFileResponse ? execFileResponse.stderr : "", []);
        });
    };
    ClientTools.prototype.execFile = function (cmd, cwd, args, _toolName, _notFoundError) {
        return new Promise(function (resolve, _reject) {
            logger$3.debug(cmd + " " + args.join(" "));
            var child = spawn(cmd, args, { cwd: cwd });
            var stdOut = "";
            var stdErr = "";
            child.stdout.on("data", function (data) {
                stdOut += data.toString();
            });
            child.stderr.on("data", function (data) {
                stdErr += data.toString();
            });
            child.on("close", function (_code, _signal) {
                resolve({
                    stdout: stdOut.trim(),
                    stderr: stdErr.trim()
                });
            });
        });
    };
    return ClientTools;
}());
function locateClientToolsInFolder(rootFolder, clientTools) {
    if (rootFolder) {
        var hpccSystemsFolder_1 = join$1(rootFolder, "HPCCSystems");
        if (existsSync(hpccSystemsFolder_1) && statSync(hpccSystemsFolder_1).isDirectory()) {
            if (type() !== "Windows_NT") {
                var eclccPath = join$1(hpccSystemsFolder_1, "bin", "eclcc");
                if (existsSync(eclccPath)) {
                    clientTools.push(new ClientTools(eclccPath));
                }
            }
            readdirSync(hpccSystemsFolder_1).forEach(function (versionFolder) {
                var eclccPath = join$1(hpccSystemsFolder_1, versionFolder, "clienttools", "bin", "eclcc" + exeExt);
                if (existsSync(eclccPath)) {
                    var name_1 = basename(versionFolder);
                    var version = new Version(name_1);
                    if (version.exists()) {
                        clientTools.push(new ClientTools(eclccPath));
                    }
                }
            });
        }
    }
}
var allClientToolsCache;
function locateAllClientTools() {
    if (allClientToolsCache)
        return allClientToolsCache;
    var clientTools = [];
    switch (type()) {
        case "Windows_NT":
            var rootFolder86 = process.env["ProgramFiles(x86)"] || "";
            if (rootFolder86) {
                locateClientToolsInFolder(rootFolder86, clientTools);
            }
            var rootFolder = process.env["ProgramFiles"] || "";
            if (rootFolder) {
                locateClientToolsInFolder(rootFolder, clientTools);
            }
            if (!rootFolder86 && !rootFolder) {
                locateClientToolsInFolder("c:\\Program Files (x86)", clientTools);
            }
            break;
        case "Linux":
        case "Darwin":
            locateClientToolsInFolder("/opt", clientTools);
            break;
    }
    allClientToolsCache = Promise.all(clientTools.map(function (ct) { return ct.version(); })).then(function () {
        clientTools.sort(function (l, r) {
            return r.versionSync().compare(l.versionSync());
        });
        return clientTools;
    });
    return allClientToolsCache;
}
var eclccPathMsg = "";
function logEclccPath(eclccPath) {
    var msg = "Using eclccPath setting:  " + eclccPath;
    if (eclccPathMsg !== msg) {
        logger$3.info(msg);
        eclccPathMsg = msg;
    }
}
function locateClientTools(overridePath, build, cwd, includeFolders, legacyMode) {
    if (overridePath === void 0) { overridePath = ""; }
    if (build === void 0) { build = ""; }
    if (cwd === void 0) { cwd = "."; }
    if (includeFolders === void 0) { includeFolders = []; }
    if (legacyMode === void 0) { legacyMode = false; }
    if (overridePath && existsSync(overridePath)) {
        logEclccPath(overridePath);
        return Promise.resolve(new ClientTools(overridePath, cwd, includeFolders, legacyMode));
    }
    return locateAllClientTools().then(function (allClientToolsCache2) {
        if (!allClientToolsCache2.length) {
            throw new Error("Unable to locate ECL Client Tools.");
        }
        var buildVersion = new Version(build);
        var latest;
        var bestMajor;
        for (var _i = 0, allClientToolsCache2_1 = allClientToolsCache2; _i < allClientToolsCache2_1.length; _i++) {
            var ct = allClientToolsCache2_1[_i];
            var ctVersion = ct.versionSync();
            if (!latest)
                latest = ct;
            if (!bestMajor && buildVersion.major === ctVersion.major)
                bestMajor = ct;
            if (buildVersion.major === ctVersion.major && buildVersion.minor === ctVersion.minor)
                return ct.clone(cwd, includeFolders, legacyMode);
        }
        var best = bestMajor || latest;
        logEclccPath(best.eclccPath);
        return best.clone(cwd, includeFolders, legacyMode);
    });
}

// DOM Parser polyfill  ---
root.DOMParser = DOMParser;
if (typeof root.fetch === "undefined") {
    root.fetch = fetch$1;
    // eslint-disable-next-line @typescript-eslint/no-var-requires
    var https = require("https");
    root.fetch.__agent = new https.Agent({
        rejectUnauthorized: false
    });
}
if (typeof root.btoa === "undefined") {
    root.btoa = function (str) {
        return Buffer.from(str || "", "utf8").toString("base64");
    };
}

export { AccountService, Activity, Attr, Attribute, BUILD_VERSION, BaseScope, ClientTools, Connection, DFUService, Definition, ECLGraph, ECLScope, ESPConnection, ESPExceptions, EclService, EclccErrors, EnvchkErrors, Errors, Field, File, Folder, GlobalResultCache, GraphCache, Import, LocalWorkunit, LogicalFile, LogicalFileCache, Machine, MachineCache, MachineService, PKG_NAME, PKG_VERSION, Query, Resource, Result, ResultCache, SMCService, Scope, ScopeEdge, ScopeGraph, ScopeSubgraph, ScopeVertex, Service, Source, SourceFile, Store, StoreCache, StoreService, TargetCluster, TargetClusterCache, Timer, Topology, TopologyService, ValueChangedMessage, Version, WUStateID, WUUpdate, Workspace, Workunit, WorkunitCache, WorkunitsService, XGMMLEdge, XGMMLGraph, XGMMLSubgraph, XGMMLVertex, XSDNode, XSDSchema, XSDSimpleType, XSDXMLNode, attachWorkspace, createConnection, createGraph, createXGMMLGraph, defaultTargetCluster, deserializeResponse, get, hookSend, instanceOfIConnection, instanceOfIOptions, isArray, isWUInfoWorkunit, isWUQueryECLWorkunit, jsonp, locateAllClientTools, locateClientTools, parseXSD, parseXSD2, post, qualifiedIDBoundary, send, serializeRequest, setTransportFactory, targetClusters, walkXmlJson$1 as walkXmlJson };
//# sourceMappingURL=index.es6.js.map