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

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@hpcc-js/util')) :
  typeof define === 'function' && define.amd ? define(['exports', '@hpcc-js/util'], factory) :
  (global = global || self, factory(global['@hpcc-js/comms'] = {}, global['@hpcc-js/util']));
}(this, (function (exports, util) { 'use strict';

  (function(self) {

    if (self.fetch) {
      return
    }

    var support = {
      searchParams: 'URLSearchParams' in self,
      iterable: 'Symbol' in self && 'iterator' in Symbol,
      blob: 'FileReader' in self && 'Blob' in self && (function() {
        try {
          new Blob();
          return true
        } catch(e) {
          return false
        }
      })(),
      formData: 'FormData' in self,
      arrayBuffer: 'ArrayBuffer' in self
    };

    if (support.arrayBuffer) {
      var viewClasses = [
        '[object Int8Array]',
        '[object Uint8Array]',
        '[object Uint8ClampedArray]',
        '[object Int16Array]',
        '[object Uint16Array]',
        '[object Int32Array]',
        '[object Uint32Array]',
        '[object Float32Array]',
        '[object Float64Array]'
      ];

      var isDataView = function(obj) {
        return obj && DataView.prototype.isPrototypeOf(obj)
      };

      var isArrayBufferView = ArrayBuffer.isView || function(obj) {
        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
      };
    }

    function normalizeName(name) {
      if (typeof name !== 'string') {
        name = String(name);
      }
      if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
        throw new TypeError('Invalid character in header field name')
      }
      return name.toLowerCase()
    }

    function normalizeValue(value) {
      if (typeof value !== 'string') {
        value = String(value);
      }
      return value
    }

    // Build a destructive iterator for the value list
    function iteratorFor(items) {
      var iterator = {
        next: function() {
          var value = items.shift();
          return {done: value === undefined, value: value}
        }
      };

      if (support.iterable) {
        iterator[Symbol.iterator] = function() {
          return iterator
        };
      }

      return iterator
    }

    function Headers(headers) {
      this.map = {};

      if (headers instanceof Headers) {
        headers.forEach(function(value, name) {
          this.append(name, value);
        }, this);
      } else if (Array.isArray(headers)) {
        headers.forEach(function(header) {
          this.append(header[0], header[1]);
        }, this);
      } else if (headers) {
        Object.getOwnPropertyNames(headers).forEach(function(name) {
          this.append(name, headers[name]);
        }, this);
      }
    }

    Headers.prototype.append = function(name, value) {
      name = normalizeName(name);
      value = normalizeValue(value);
      var oldValue = this.map[name];
      this.map[name] = oldValue ? oldValue+','+value : value;
    };

    Headers.prototype['delete'] = function(name) {
      delete this.map[normalizeName(name)];
    };

    Headers.prototype.get = function(name) {
      name = normalizeName(name);
      return this.has(name) ? this.map[name] : null
    };

    Headers.prototype.has = function(name) {
      return this.map.hasOwnProperty(normalizeName(name))
    };

    Headers.prototype.set = function(name, value) {
      this.map[normalizeName(name)] = normalizeValue(value);
    };

    Headers.prototype.forEach = function(callback, thisArg) {
      for (var name in this.map) {
        if (this.map.hasOwnProperty(name)) {
          callback.call(thisArg, this.map[name], name, this);
        }
      }
    };

    Headers.prototype.keys = function() {
      var items = [];
      this.forEach(function(value, name) { items.push(name); });
      return iteratorFor(items)
    };

    Headers.prototype.values = function() {
      var items = [];
      this.forEach(function(value) { items.push(value); });
      return iteratorFor(items)
    };

    Headers.prototype.entries = function() {
      var items = [];
      this.forEach(function(value, name) { items.push([name, value]); });
      return iteratorFor(items)
    };

    if (support.iterable) {
      Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
    }

    function consumed(body) {
      if (body.bodyUsed) {
        return Promise.reject(new TypeError('Already read'))
      }
      body.bodyUsed = true;
    }

    function fileReaderReady(reader) {
      return new Promise(function(resolve, reject) {
        reader.onload = function() {
          resolve(reader.result);
        };
        reader.onerror = function() {
          reject(reader.error);
        };
      })
    }

    function readBlobAsArrayBuffer(blob) {
      var reader = new FileReader();
      var promise = fileReaderReady(reader);
      reader.readAsArrayBuffer(blob);
      return promise
    }

    function readBlobAsText(blob) {
      var reader = new FileReader();
      var promise = fileReaderReady(reader);
      reader.readAsText(blob);
      return promise
    }

    function readArrayBufferAsText(buf) {
      var view = new Uint8Array(buf);
      var chars = new Array(view.length);

      for (var i = 0; i < view.length; i++) {
        chars[i] = String.fromCharCode(view[i]);
      }
      return chars.join('')
    }

    function bufferClone(buf) {
      if (buf.slice) {
        return buf.slice(0)
      } else {
        var view = new Uint8Array(buf.byteLength);
        view.set(new Uint8Array(buf));
        return view.buffer
      }
    }

    function Body() {
      this.bodyUsed = false;

      this._initBody = function(body) {
        this._bodyInit = body;
        if (!body) {
          this._bodyText = '';
        } else if (typeof body === 'string') {
          this._bodyText = body;
        } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
          this._bodyBlob = body;
        } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
          this._bodyFormData = body;
        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
          this._bodyText = body.toString();
        } else if (support.arrayBuffer && support.blob && isDataView(body)) {
          this._bodyArrayBuffer = bufferClone(body.buffer);
          // IE 10-11 can't handle a DataView body.
          this._bodyInit = new Blob([this._bodyArrayBuffer]);
        } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
          this._bodyArrayBuffer = bufferClone(body);
        } else {
          throw new Error('unsupported BodyInit type')
        }

        if (!this.headers.get('content-type')) {
          if (typeof body === 'string') {
            this.headers.set('content-type', 'text/plain;charset=UTF-8');
          } else if (this._bodyBlob && this._bodyBlob.type) {
            this.headers.set('content-type', this._bodyBlob.type);
          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
            this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
          }
        }
      };

      if (support.blob) {
        this.blob = function() {
          var rejected = consumed(this);
          if (rejected) {
            return rejected
          }

          if (this._bodyBlob) {
            return Promise.resolve(this._bodyBlob)
          } else if (this._bodyArrayBuffer) {
            return Promise.resolve(new Blob([this._bodyArrayBuffer]))
          } else if (this._bodyFormData) {
            throw new Error('could not read FormData body as blob')
          } else {
            return Promise.resolve(new Blob([this._bodyText]))
          }
        };

        this.arrayBuffer = function() {
          if (this._bodyArrayBuffer) {
            return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
          } else {
            return this.blob().then(readBlobAsArrayBuffer)
          }
        };
      }

      this.text = function() {
        var rejected = consumed(this);
        if (rejected) {
          return rejected
        }

        if (this._bodyBlob) {
          return readBlobAsText(this._bodyBlob)
        } else if (this._bodyArrayBuffer) {
          return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
        } else if (this._bodyFormData) {
          throw new Error('could not read FormData body as text')
        } else {
          return Promise.resolve(this._bodyText)
        }
      };

      if (support.formData) {
        this.formData = function() {
          return this.text().then(decode)
        };
      }

      this.json = function() {
        return this.text().then(JSON.parse)
      };

      return this
    }

    // HTTP methods whose capitalization should be normalized
    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];

    function normalizeMethod(method) {
      var upcased = method.toUpperCase();
      return (methods.indexOf(upcased) > -1) ? upcased : method
    }

    function Request(input, options) {
      options = options || {};
      var body = options.body;

      if (input instanceof Request) {
        if (input.bodyUsed) {
          throw new TypeError('Already read')
        }
        this.url = input.url;
        this.credentials = input.credentials;
        if (!options.headers) {
          this.headers = new Headers(input.headers);
        }
        this.method = input.method;
        this.mode = input.mode;
        if (!body && input._bodyInit != null) {
          body = input._bodyInit;
          input.bodyUsed = true;
        }
      } else {
        this.url = String(input);
      }

      this.credentials = options.credentials || this.credentials || 'omit';
      if (options.headers || !this.headers) {
        this.headers = new Headers(options.headers);
      }
      this.method = normalizeMethod(options.method || this.method || 'GET');
      this.mode = options.mode || this.mode || null;
      this.referrer = null;

      if ((this.method === 'GET' || this.method === 'HEAD') && body) {
        throw new TypeError('Body not allowed for GET or HEAD requests')
      }
      this._initBody(body);
    }

    Request.prototype.clone = function() {
      return new Request(this, { body: this._bodyInit })
    };

    function decode(body) {
      var form = new FormData();
      body.trim().split('&').forEach(function(bytes) {
        if (bytes) {
          var split = bytes.split('=');
          var name = split.shift().replace(/\+/g, ' ');
          var value = split.join('=').replace(/\+/g, ' ');
          form.append(decodeURIComponent(name), decodeURIComponent(value));
        }
      });
      return form
    }

    function parseHeaders(rawHeaders) {
      var headers = new Headers();
      rawHeaders.split(/\r?\n/).forEach(function(line) {
        var parts = line.split(':');
        var key = parts.shift().trim();
        if (key) {
          var value = parts.join(':').trim();
          headers.append(key, value);
        }
      });
      return headers
    }

    Body.call(Request.prototype);

    function Response(bodyInit, options) {
      if (!options) {
        options = {};
      }

      this.type = 'default';
      this.status = 'status' in options ? options.status : 200;
      this.ok = this.status >= 200 && this.status < 300;
      this.statusText = 'statusText' in options ? options.statusText : 'OK';
      this.headers = new Headers(options.headers);
      this.url = options.url || '';
      this._initBody(bodyInit);
    }

    Body.call(Response.prototype);

    Response.prototype.clone = function() {
      return new Response(this._bodyInit, {
        status: this.status,
        statusText: this.statusText,
        headers: new Headers(this.headers),
        url: this.url
      })
    };

    Response.error = function() {
      var response = new Response(null, {status: 0, statusText: ''});
      response.type = 'error';
      return response
    };

    var redirectStatuses = [301, 302, 303, 307, 308];

    Response.redirect = function(url, status) {
      if (redirectStatuses.indexOf(status) === -1) {
        throw new RangeError('Invalid status code')
      }

      return new Response(null, {status: status, headers: {location: url}})
    };

    self.Headers = Headers;
    self.Request = Request;
    self.Response = Response;

    self.fetch = function(input, init) {
      return new Promise(function(resolve, reject) {
        var request = new Request(input, init);
        var xhr = new XMLHttpRequest();

        xhr.onload = function() {
          var options = {
            status: xhr.status,
            statusText: xhr.statusText,
            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
          };
          options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
          var body = 'response' in xhr ? xhr.response : xhr.responseText;
          resolve(new Response(body, options));
        };

        xhr.onerror = function() {
          reject(new TypeError('Network request failed'));
        };

        xhr.ontimeout = function() {
          reject(new TypeError('Network request failed'));
        };

        xhr.open(request.method, request.url, true);

        if (request.credentials === 'include') {
          xhr.withCredentials = true;
        }

        if ('responseType' in xhr && support.blob) {
          xhr.responseType = 'blob';
        }

        request.headers.forEach(function(value, name) {
          xhr.setRequestHeader(name, value);
        });

        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
      })
    };
    self.fetch.polyfill = true;
  })(typeof self !== 'undefined' ? self : undefined);

  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 };
      }
  }

  var logger = util.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 = util.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 util.promiseTimeout(opts.timeoutSecs * 1000, fetch(util.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(util.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;
  }());
  exports.createConnection = function (opts) {
      return new Connection(opts);
  };
  function setTransportFactory(newFunc) {
      var retVal = exports.createConnection;
      exports.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 : exports.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 = util.join(this._service, action);
                  responseType = "text";
                  break;
              case "xsd":
                  serviceAction = util.join(this._service, action + ".xsd");
                  responseType = "text";
                  break;
              case "json2":
                  serviceAction = util.join(this._service, action + "/json");
                  espResponseType = "json";
                  var actionParts = action.split("/");
                  action = actionParts.pop();
                  break;
              default:
                  serviceAction = util.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 util.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));

  (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";
  })(exports.WUStateID || (exports.WUStateID = {}));
  (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 = {}));
  })(exports.WUUpdate || (exports.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 util.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 = util.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;
  }(util.StateObject));
  var GraphCache = /** @class */ (function (_super) {
      __extends(GraphCache, _super);
      function GraphCache() {
          return _super.call(this, function (obj) {
              return util.Cache.hash([obj.Name]);
          }) || this;
      }
      return GraphCache;
  }(util.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;
  }(util.Graph));
  var XGMMLSubgraph = /** @class */ (function (_super) {
      __extends(XGMMLSubgraph, _super);
      function XGMMLSubgraph() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return XGMMLSubgraph;
  }(util.Subgraph));
  var XGMMLVertex = /** @class */ (function (_super) {
      __extends(XGMMLVertex, _super);
      function XGMMLVertex() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return XGMMLVertex;
  }(util.Vertex));
  var XGMMLEdge = /** @class */ (function (_super) {
      __extends(XGMMLEdge, _super);
      function XGMMLEdge() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return XGMMLEdge;
  }(util.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;
  }(util.Graph));
  var ScopeSubgraph = /** @class */ (function (_super) {
      __extends(ScopeSubgraph, _super);
      function ScopeSubgraph() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return ScopeSubgraph;
  }(util.Subgraph));
  var ScopeVertex = /** @class */ (function (_super) {
      __extends(ScopeVertex, _super);
      function ScopeVertex() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return ScopeVertex;
  }(util.Vertex));
  var ScopeEdge = /** @class */ (function (_super) {
      __extends(ScopeEdge, _super);
      function ScopeEdge() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return ScopeEdge;
  }(util.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;
  }(util.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 util.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;
  }(util.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 util.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;
  }(util.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 (util.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 (util.exists("XmlSchema.xml", result)) {
                  _this.xsdSchema = parseXSD(result.XmlSchema.xml);
              }
              if (util.exists("Row", result)) {
                  return result.Row;
              }
              else if (_this.ResultName && util.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;
  }(util.StateObject));
  var ResultCache = /** @class */ (function (_super) {
      __extends(ResultCache, _super);
      function ResultCache() {
          return _super.call(this, function (obj) {
              return util.Cache.hash([obj.Sequence, obj.Name, obj.FileName]);
          }) || this;
      }
      return ResultCache;
  }(util.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;
  }(util.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;
  }(util.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;
  }(util.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 = util.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;
  }(util.StateObject));

  var formatter = utcFormat("%Y-%m-%dT%H:%M:%S.%LZ");
  var parser = utcParse("%Y-%m-%dT%H:%M:%S.%LZ");
  var logger$1 = util.scopedLogger("workunit.ts");
  var WUStateID = exports.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;
  }(util.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", exports.WUStateID.Unknown); },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Workunit.prototype, "State", {
          get: function () { return this.get("State") || exports.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.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 = exports.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 === exports.WUUpdate.Action.Debug) {
              action = exports.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.Compiled:
                  return this.ActionEx === "compile" || this._submitAction === exports.WUUpdate.Action.Compile;
              case WUStateID.Completed:
              case WUStateID.Failed:
              case WUStateID.Aborted:
              case WUStateID.NotFound:
                  return true;
          }
          return false;
      };
      Workunit.prototype.isFailed = function () {
          switch (this.StateID) {
              case WUStateID.Aborted:
              case WUStateID.Failed:
                  return true;
          }
          return false;
      };
      Workunit.prototype.isDeleted = function () {
          switch (this.StateID) {
              case WUStateID.NotFound:
                  return true;
          }
          return false;
      };
      Workunit.prototype.isDebugging = function () {
          switch (this.StateID) {
              case WUStateID.DebugPaused:
              case WUStateID.DebugRunning:
                  return true;
          }
          return this._debugMode;
      };
      Workunit.prototype.isRunning = function () {
          switch (this.StateID) {
              case WUStateID.Compiled:
              case WUStateID.Running:
              case WUStateID.Aborting:
              case WUStateID.Blocked:
              case WUStateID.DebugPaused:
              case WUStateID.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.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.NotFound);
                      return true;
                  }
                  return false;
              });
              if (!wuMissing) {
                  logger$1.warning("Unexpected exception:  ");
                  throw e;
              }
              return {};
          });
      };
      Workunit.prototype.WUResubmit = function (request) {
          return this.connection.WUResubmit(util.deepMixinT({}, request, {
              Wuids: [this.Wuid]
          }));
      };
      Workunit.prototype.WUDetailsMeta = function (request) {
          return this.connection.WUDetailsMeta(request);
      };
      Workunit.prototype.WUDetails = function (request) {
          return this.connection.WUDetails(util.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 util.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 util.XMLNode(command));
          }
          return this.WUCDebug(command, opts).then(function (response) {
              var retVal = response.children(command);
              if (retVal.length) {
                  return retVal[0];
              }
              return new util.XMLNode(command);
          }).catch(function (_) {
              logger$1.error(_);
              return Promise.resolve(new util.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;
  }(util.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 = util.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;
  }(util.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;
  }(util.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;
  }(util.StateObject));

  var MachineCache = /** @class */ (function (_super) {
      __extends(MachineCache, _super);
      function MachineCache() {
          return _super.call(this, function (obj) {
              return obj.Address;
          }) || this;
      }
      return MachineCache;
  }(util.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;
  }(util.StateObject));

  var QueryCache = /** @class */ (function (_super) {
      __extends(QueryCache, _super);
      function QueryCache() {
          return _super.call(this, function (obj) {
              return util.Cache.hash([obj.QueryId, obj.QuerySet]);
          }) || this;
      }
      return QueryCache;
  }(util.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;
  }(util.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;
  }(util.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;
  }(util.Message));
  var Store = /** @class */ (function () {
      function Store(optsConnection, Name, Namespace, UserSpecific) {
          this._dispatch = new util.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;
  }(util.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;
  }(util.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 (util.exists("ServiceList.TpEspServers.TpEspServer", response)) {
                  for (var _i = 0, _a = response.ServiceList.TpEspServers.TpEspServer; _i < _a.length; _i++) {
                      var item = _a[_i];
                      if (util.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;
  }(util.StateObject));

  exports.AccountService = AccountService;
  exports.Activity = Activity;
  exports.Attribute = Attribute;
  exports.BUILD_VERSION = BUILD_VERSION;
  exports.BaseScope = BaseScope;
  exports.Connection = Connection;
  exports.DFUService = DFUService;
  exports.ECLGraph = ECLGraph;
  exports.ESPConnection = ESPConnection;
  exports.ESPExceptions = ESPExceptions;
  exports.EclService = EclService;
  exports.GlobalResultCache = GlobalResultCache;
  exports.GraphCache = GraphCache;
  exports.LogicalFile = LogicalFile;
  exports.LogicalFileCache = LogicalFileCache;
  exports.Machine = Machine;
  exports.MachineCache = MachineCache;
  exports.MachineService = MachineService;
  exports.PKG_NAME = PKG_NAME;
  exports.PKG_VERSION = PKG_VERSION;
  exports.Query = Query;
  exports.Resource = Resource;
  exports.Result = Result;
  exports.ResultCache = ResultCache;
  exports.SMCService = SMCService;
  exports.Scope = Scope;
  exports.ScopeEdge = ScopeEdge;
  exports.ScopeGraph = ScopeGraph;
  exports.ScopeSubgraph = ScopeSubgraph;
  exports.ScopeVertex = ScopeVertex;
  exports.Service = Service;
  exports.SourceFile = SourceFile;
  exports.Store = Store;
  exports.StoreCache = StoreCache;
  exports.StoreService = StoreService;
  exports.TargetCluster = TargetCluster;
  exports.TargetClusterCache = TargetClusterCache;
  exports.Timer = Timer;
  exports.Topology = Topology;
  exports.TopologyService = TopologyService;
  exports.ValueChangedMessage = ValueChangedMessage;
  exports.Workunit = Workunit;
  exports.WorkunitCache = WorkunitCache;
  exports.WorkunitsService = WorkunitsService;
  exports.XGMMLEdge = XGMMLEdge;
  exports.XGMMLGraph = XGMMLGraph;
  exports.XGMMLSubgraph = XGMMLSubgraph;
  exports.XGMMLVertex = XGMMLVertex;
  exports.XSDNode = XSDNode;
  exports.XSDSchema = XSDSchema;
  exports.XSDSimpleType = XSDSimpleType;
  exports.XSDXMLNode = XSDXMLNode;
  exports.createGraph = createGraph;
  exports.createXGMMLGraph = createXGMMLGraph;
  exports.defaultTargetCluster = defaultTargetCluster;
  exports.deserializeResponse = deserializeResponse;
  exports.get = get;
  exports.hookSend = hookSend;
  exports.instanceOfIConnection = instanceOfIConnection;
  exports.instanceOfIOptions = instanceOfIOptions;
  exports.isArray = isArray;
  exports.isWUInfoWorkunit = isWUInfoWorkunit;
  exports.isWUQueryECLWorkunit = isWUQueryECLWorkunit;
  exports.jsonp = jsonp;
  exports.parseXSD = parseXSD;
  exports.parseXSD2 = parseXSD2;
  exports.post = post;
  exports.send = send;
  exports.serializeRequest = serializeRequest;
  exports.setTransportFactory = setTransportFactory;
  exports.targetClusters = targetClusters;

  Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=index.js.map