@hpcc-js/comms 2.78.1 → 2.79.1

package/dist/index.js

@@ -611,10 +611,10 @@
   }
 
   var PKG_NAME = "@hpcc-js/comms";
-  var PKG_VERSION = "2.78.1";
-  var BUILD_VERSION = "2.103.5";
+  var PKG_VERSION = "2.79.1";
+  var BUILD_VERSION = "2.104.2";
 
-  /*! *****************************************************************************
+  /******************************************************************************
   Copyright (c) Microsoft Corporation.
 
   Permission to use, copy, modify, and/or distribute this software for any
@@ -1577,145 +1577,145 @@
       return DaliService;
   }(DaliServiceBase));
 
-  exports.DFUArrayActions = void 0;
-  (function (DFUArrayActions) {
-      DFUArrayActions["Delete"] = "Delete";
-      DFUArrayActions["AddToSuperfile"] = "AddToSuperfile";
-      DFUArrayActions["ChangeProtection"] = "ChangeProtection";
-      DFUArrayActions["ChangeRestriction"] = "ChangeRestriction";
-  })(exports.DFUArrayActions || (exports.DFUArrayActions = {}));
-  exports.DFUChangeProtection = void 0;
-  (function (DFUChangeProtection) {
-      DFUChangeProtection[DFUChangeProtection["NoChange"] = 0] = "NoChange";
-      DFUChangeProtection[DFUChangeProtection["Protect"] = 1] = "Protect";
-      DFUChangeProtection[DFUChangeProtection["Unprotect"] = 2] = "Unprotect";
-      DFUChangeProtection[DFUChangeProtection["UnprotectAll"] = 3] = "UnprotectAll";
-  })(exports.DFUChangeProtection || (exports.DFUChangeProtection = {}));
-  exports.DFUChangeRestriction = void 0;
-  (function (DFUChangeRestriction) {
-      DFUChangeRestriction[DFUChangeRestriction["NoChange"] = 0] = "NoChange";
-      DFUChangeRestriction[DFUChangeRestriction["Restrict"] = 1] = "Restrict";
-      DFUChangeRestriction[DFUChangeRestriction["Unrestricted"] = 2] = "Unrestricted";
-  })(exports.DFUChangeRestriction || (exports.DFUChangeRestriction = {}));
-  exports.DFUDefFileFormat = void 0;
-  (function (DFUDefFileFormat) {
-      DFUDefFileFormat["Xml"] = "Xml";
-      DFUDefFileFormat["Def"] = "Def";
-  })(exports.DFUDefFileFormat || (exports.DFUDefFileFormat = {}));
-  exports.FileAccessRole = void 0;
-  (function (FileAccessRole) {
-      FileAccessRole["Token"] = "Token";
-      FileAccessRole["Engine"] = "Engine";
-      FileAccessRole["External"] = "External";
-  })(exports.FileAccessRole || (exports.FileAccessRole = {}));
-  exports.SecAccessType = void 0;
-  (function (SecAccessType) {
-      SecAccessType["None"] = "None";
-      SecAccessType["Access"] = "Access";
-      SecAccessType["Read"] = "Read";
-      SecAccessType["Write"] = "Write";
-      SecAccessType["Full"] = "Full";
-  })(exports.SecAccessType || (exports.SecAccessType = {}));
-  exports.DFUFileType = void 0;
-  (function (DFUFileType) {
-      DFUFileType["Flat"] = "Flat";
-      DFUFileType["Index"] = "Index";
-      DFUFileType["Xml"] = "Xml";
-      DFUFileType["Csv"] = "Csv";
-      DFUFileType["Json"] = "Json";
-      DFUFileType["IndexLocal"] = "IndexLocal";
-      DFUFileType["IndexPartitioned"] = "IndexPartitioned";
-      DFUFileType["Unset"] = "Unset";
-  })(exports.DFUFileType || (exports.DFUFileType = {}));
+  exports.WsDfu = void 0;
+  (function (WsDfu) {
+      (function (DFUArrayActions) {
+          DFUArrayActions["Delete"] = "Delete";
+          DFUArrayActions["AddToSuperfile"] = "AddToSuperfile";
+          DFUArrayActions["ChangeProtection"] = "ChangeProtection";
+          DFUArrayActions["ChangeRestriction"] = "ChangeRestriction";
+      })(WsDfu.DFUArrayActions || (WsDfu.DFUArrayActions = {}));
+      (function (DFUChangeProtection) {
+          DFUChangeProtection[DFUChangeProtection["NoChange"] = 0] = "NoChange";
+          DFUChangeProtection[DFUChangeProtection["Protect"] = 1] = "Protect";
+          DFUChangeProtection[DFUChangeProtection["Unprotect"] = 2] = "Unprotect";
+          DFUChangeProtection[DFUChangeProtection["UnprotectAll"] = 3] = "UnprotectAll";
+      })(WsDfu.DFUChangeProtection || (WsDfu.DFUChangeProtection = {}));
+      (function (DFUChangeRestriction) {
+          DFUChangeRestriction[DFUChangeRestriction["NoChange"] = 0] = "NoChange";
+          DFUChangeRestriction[DFUChangeRestriction["Restrict"] = 1] = "Restrict";
+          DFUChangeRestriction[DFUChangeRestriction["Unrestricted"] = 2] = "Unrestricted";
+      })(WsDfu.DFUChangeRestriction || (WsDfu.DFUChangeRestriction = {}));
+      (function (DFUDefFileFormat) {
+          DFUDefFileFormat["xml"] = "xml";
+          DFUDefFileFormat["def"] = "def";
+      })(WsDfu.DFUDefFileFormat || (WsDfu.DFUDefFileFormat = {}));
+      (function (FileAccessRole) {
+          FileAccessRole["Token"] = "Token";
+          FileAccessRole["Engine"] = "Engine";
+          FileAccessRole["External"] = "External";
+      })(WsDfu.FileAccessRole || (WsDfu.FileAccessRole = {}));
+      (function (SecAccessType) {
+          SecAccessType["None"] = "None";
+          SecAccessType["Access"] = "Access";
+          SecAccessType["Read"] = "Read";
+          SecAccessType["Write"] = "Write";
+          SecAccessType["Full"] = "Full";
+      })(WsDfu.SecAccessType || (WsDfu.SecAccessType = {}));
+      (function (DFUFileType) {
+          DFUFileType["Flat"] = "Flat";
+          DFUFileType["Index"] = "Index";
+          DFUFileType["Xml"] = "Xml";
+          DFUFileType["Csv"] = "Csv";
+          DFUFileType["Json"] = "Json";
+          DFUFileType["IndexLocal"] = "IndexLocal";
+          DFUFileType["IndexPartitioned"] = "IndexPartitioned";
+          DFUFileType["Unset"] = "Unset";
+      })(WsDfu.DFUFileType || (WsDfu.DFUFileType = {}));
+  })(exports.WsDfu || (exports.WsDfu = {}));
   var DfuServiceBase = /** @class */ (function (_super) {
       __extends(DfuServiceBase, _super);
       function DfuServiceBase(optsConnection) {
           return _super.call(this, optsConnection, "WsDfu", "1.63") || this;
       }
       DfuServiceBase.prototype.Add = function (request) {
-          return this._connection.send("Add", request);
+          return this._connection.send("Add", request, "json", false, undefined, "AddResponse");
       };
       DfuServiceBase.prototype.AddRemote = function (request) {
-          return this._connection.send("AddRemote", request);
+          return this._connection.send("AddRemote", request, "json", false, undefined, "AddRemoteResponse");
       };
       DfuServiceBase.prototype.AddtoSuperfile = function (request) {
-          return this._connection.send("AddtoSuperfile", request);
+          return this._connection.send("AddtoSuperfile", request, "json", false, undefined, "AddtoSuperfileResponse");
       };
       DfuServiceBase.prototype.DFUArrayAction = function (request) {
-          return this._connection.send("DFUArrayAction", request);
+          return this._connection.send("DFUArrayAction", request, "json", false, undefined, "DFUArrayActionResponse");
       };
       DfuServiceBase.prototype.DFUBrowseData = function (request) {
-          return this._connection.send("DFUBrowseData", request);
+          return this._connection.send("DFUBrowseData", request, "json", false, undefined, "DFUBrowseDataResponse");
       };
       DfuServiceBase.prototype.DFUDefFile = function (request) {
-          return this._connection.send("DFUDefFile", request);
+          return this._connection.send("DFUDefFile", request, "json", false, undefined, "DFUDefFileResponse");
       };
       DfuServiceBase.prototype.DFUFileAccess = function (request) {
-          return this._connection.send("DFUFileAccess", request);
+          return this._connection.send("DFUFileAccess", request, "json", false, undefined, "DFUFileAccessResponse");
       };
       DfuServiceBase.prototype.DFUFileAccessV2 = function (request) {
-          return this._connection.send("DFUFileAccessV2", request);
+          return this._connection.send("DFUFileAccessV2", request, "json", false, undefined, "DFUFileAccessResponse");
       };
       DfuServiceBase.prototype.DFUFileCreate = function (request) {
-          return this._connection.send("DFUFileCreate", request);
+          return this._connection.send("DFUFileCreate", request, "json", false, undefined, "DFUFileCreateResponse");
       };
       DfuServiceBase.prototype.DFUFileCreateV2 = function (request) {
-          return this._connection.send("DFUFileCreateV2", request);
+          return this._connection.send("DFUFileCreateV2", request, "json", false, undefined, "DFUFileCreateResponse");
       };
       DfuServiceBase.prototype.DFUFilePublish = function (request) {
-          return this._connection.send("DFUFilePublish", request);
+          return this._connection.send("DFUFilePublish", request, "json", false, undefined, "DFUFilePublishResponse");
       };
       DfuServiceBase.prototype.DFUFileView = function (request) {
-          return this._connection.send("DFUFileView", request);
+          return this._connection.send("DFUFileView", request, "json", false, undefined, "DFUFileViewResponse");
       };
       DfuServiceBase.prototype.DFUGetDataColumns = function (request) {
-          return this._connection.send("DFUGetDataColumns", request);
+          return this._connection.send("DFUGetDataColumns", request, "json", false, undefined, "DFUGetDataColumnsResponse");
       };
       DfuServiceBase.prototype.DFUGetFileMetaData = function (request) {
-          return this._connection.send("DFUGetFileMetaData", request);
+          return this._connection.send("DFUGetFileMetaData", request, "json", false, undefined, "DFUGetFileMetaDataResponse");
       };
       DfuServiceBase.prototype.DFUInfo = function (request) {
-          return this._connection.send("DFUInfo", request);
+          return this._connection.send("DFUInfo", request, "json", false, undefined, "DFUInfoResponse");
       };
       DfuServiceBase.prototype.DFUQuery = function (request) {
-          return this._connection.send("DFUQuery", request);
+          return this._connection.send("DFUQuery", request, "json", false, undefined, "DFUQueryResponse");
       };
       DfuServiceBase.prototype.DFURecordTypeInfo = function (request) {
-          return this._connection.send("DFURecordTypeInfo", request);
+          return this._connection.send("DFURecordTypeInfo", request, "json", false, undefined, "DFURecordTypeInfoResponse");
       };
       DfuServiceBase.prototype.DFUSearch = function (request) {
-          return this._connection.send("DFUSearch", request);
+          return this._connection.send("DFUSearch", request, "json", false, undefined, "DFUSearchResponse");
       };
       DfuServiceBase.prototype.DFUSearchData = function (request) {
-          return this._connection.send("DFUSearchData", request);
+          return this._connection.send("DFUSearchData", request, "json", false, undefined, "DFUSearchDataResponse");
       };
       DfuServiceBase.prototype.DFUSpace = function (request) {
-          return this._connection.send("DFUSpace", request);
+          return this._connection.send("DFUSpace", request, "json", false, undefined, "DFUSpaceResponse");
       };
       DfuServiceBase.prototype.EclRecordTypeInfo = function (request) {
-          return this._connection.send("EclRecordTypeInfo", request);
+          return this._connection.send("EclRecordTypeInfo", request, "json", false, undefined, "EclRecordTypeInfoResponse");
       };
       DfuServiceBase.prototype.EraseHistory = function (request) {
-          return this._connection.send("EraseHistory", request);
+          return this._connection.send("EraseHistory", request, "json", false, undefined, "EraseHistoryResponse");
       };
       DfuServiceBase.prototype.ListHistory = function (request) {
-          return this._connection.send("ListHistory", request);
+          return this._connection.send("ListHistory", request, "json", false, undefined, "ListHistoryResponse");
       };
       DfuServiceBase.prototype.Ping = function (request) {
-          return this._connection.send("Ping", request);
+          return this._connection.send("Ping", request, "json", false, undefined, "WsDfuPingResponse");
       };
       DfuServiceBase.prototype.Savexml = function (request) {
-          return this._connection.send("Savexml", request);
+          return this._connection.send("Savexml", request, "json", false, undefined, "SavexmlResponse");
       };
       DfuServiceBase.prototype.SuperfileAction = function (request) {
-          return this._connection.send("SuperfileAction", request);
+          return this._connection.send("SuperfileAction", request, "json", false, undefined, "SuperfileActionResponse");
       };
       DfuServiceBase.prototype.SuperfileList = function (request) {
-          return this._connection.send("SuperfileList", request);
+          return this._connection.send("SuperfileList", request, "json", false, undefined, "SuperfileListResponse");
       };
       return DfuServiceBase;
   }(Service));
 
+  var DFUArrayActions = exports.WsDfu.DFUArrayActions;
+  var DFUDefFileFormat = exports.WsDfu.DFUDefFileFormat;
+  var DFUChangeProtection = exports.WsDfu.DFUChangeProtection;
+  var DFUChangeRestriction = exports.WsDfu.DFUChangeRestriction;
   var DFUService = /** @class */ (function (_super) {
       __extends(DFUService, _super);
       function DFUService() {
@@ -1903,7 +1903,7 @@
   (function (WsLogaccess) {
       (function (LogAccessType) {
           LogAccessType[LogAccessType["All"] = 0] = "All";
-          LogAccessType[LogAccessType["ByJobIdID"] = 1] = "ByJobIdID";
+          LogAccessType[LogAccessType["ByJobID"] = 1] = "ByJobID";
           LogAccessType[LogAccessType["ByComponent"] = 2] = "ByComponent";
           LogAccessType[LogAccessType["ByLogType"] = 3] = "ByLogType";
           LogAccessType[LogAccessType["ByTargetAudience"] = 4] = "ByTargetAudience";
@@ -1922,47 +1922,88 @@
           LogSelectColumnMode[LogSelectColumnMode["ALL"] = 2] = "ALL";
           LogSelectColumnMode[LogSelectColumnMode["CUSTOM"] = 3] = "CUSTOM";
       })(WsLogaccess.LogSelectColumnMode || (WsLogaccess.LogSelectColumnMode = {}));
+      (function (SortColumType) {
+          SortColumType[SortColumType["ByDate"] = 0] = "ByDate";
+          SortColumType[SortColumType["ByJobID"] = 1] = "ByJobID";
+          SortColumType[SortColumType["ByComponent"] = 2] = "ByComponent";
+          SortColumType[SortColumType["ByLogType"] = 3] = "ByLogType";
+          SortColumType[SortColumType["ByTargetAudience"] = 4] = "ByTargetAudience";
+          SortColumType[SortColumType["BySourceInstance"] = 5] = "BySourceInstance";
+          SortColumType[SortColumType["BySourceNode"] = 6] = "BySourceNode";
+          SortColumType[SortColumType["ByFieldName"] = 7] = "ByFieldName";
+      })(WsLogaccess.SortColumType || (WsLogaccess.SortColumType = {}));
+      (function (SortDirection) {
+          SortDirection[SortDirection["ASC"] = 0] = "ASC";
+          SortDirection[SortDirection["DSC"] = 1] = "DSC";
+      })(WsLogaccess.SortDirection || (WsLogaccess.SortDirection = {}));
   })(exports.WsLogaccess || (exports.WsLogaccess = {}));
   var LogaccessServiceBase = /** @class */ (function (_super) {
       __extends(LogaccessServiceBase, _super);
       function LogaccessServiceBase(optsConnection) {
-          return _super.call(this, optsConnection, "ws_logaccess", "1.02") || this;
+          return _super.call(this, optsConnection, "ws_logaccess", "1.03") || this;
       }
       LogaccessServiceBase.prototype.GetLogAccessInfo = function (request) {
-          return this._connection.send("GetLogAccessInfo", request);
+          return this._connection.send("GetLogAccessInfo", request, "json", false, undefined, "GetLogAccessInfoResponse");
       };
       LogaccessServiceBase.prototype.GetLogs = function (request) {
-          return this._connection.send("GetLogs", request);
+          return this._connection.send("GetLogs", request, "json", false, undefined, "GetLogsResponse");
       };
       LogaccessServiceBase.prototype.Ping = function (request) {
-          return this._connection.send("Ping", request);
+          return this._connection.send("Ping", request, "json", false, undefined, "ws_logaccessPingResponse");
       };
       return LogaccessServiceBase;
   }(Service));
 
   var logger$1 = util.scopedLogger("@hpcc-js/comms/services/wsLogaccess.ts");
-  exports.KnownColumns = void 0;
-  (function (KnownColumns) {
-      KnownColumns["audience"] = "hpcc.log.audience";
-      KnownColumns["class"] = "hpcc.log.class";
-      KnownColumns["jobId"] = "hpcc.log.jobid";
-      KnownColumns["message"] = "hpcc.log.message";
-      KnownColumns["procId"] = "hpcc.log.procid";
-      KnownColumns["sequence"] = "hpcc.log.sequence";
-      KnownColumns["threadId"] = "hpcc.log.threadid";
-      KnownColumns["timestamp"] = "hpcc.log.timestamp";
-      KnownColumns["containerName"] = "kubernetes.container.name";
-  })(exports.KnownColumns || (exports.KnownColumns = {}));
-  var RKnownColumns = {};
-  for (var key in exports.KnownColumns) {
-      if (exports.KnownColumns.hasOwnProperty(key)) {
-          RKnownColumns[exports.KnownColumns[key]] = key;
+  var ElasticKnownColumns;
+  (function (ElasticKnownColumns) {
+      ElasticKnownColumns["audience"] = "hpcc.log.audience";
+      ElasticKnownColumns["class"] = "hpcc.log.class";
+      ElasticKnownColumns["containerName"] = "kubernetes.container.name";
+      ElasticKnownColumns["jobId"] = "hpcc.log.jobid";
+      ElasticKnownColumns["message"] = "hpcc.log.message";
+      ElasticKnownColumns["procId"] = "hpcc.log.procid";
+      ElasticKnownColumns["sequence"] = "hpcc.log.sequence";
+      ElasticKnownColumns["threadId"] = "hpcc.log.threadid";
+      ElasticKnownColumns["timestamp"] = "hpcc.log.timestamp";
+  })(ElasticKnownColumns || (ElasticKnownColumns = {}));
+  var RElasticKnownColumns = {};
+  for (var key in ElasticKnownColumns) {
+      if (ElasticKnownColumns.hasOwnProperty(key)) {
+          RElasticKnownColumns[ElasticKnownColumns[key]] = key;
+      }
+  }
+  var elasticToLogLine = function (line) {
+      var retVal = {};
+      for (var key in RElasticKnownColumns) {
+          retVal[RElasticKnownColumns[key]] = line === null || line === void 0 ? void 0 : line.fields[0][key];
+      }
+      return retVal;
+  };
+  var AzureKnownColumns;
+  (function (AzureKnownColumns) {
+      AzureKnownColumns["audience"] = "hpcc_log_audience";
+      AzureKnownColumns["class"] = "hpcc_log_class";
+      AzureKnownColumns["containerID"] = "ContainerID";
+      AzureKnownColumns["containerName"] = "ContainerID";
+      AzureKnownColumns["jobId"] = "hpcc_log_jobid";
+      AzureKnownColumns["message"] = "hpcc_log_message";
+      AzureKnownColumns["procId"] = "";
+      AzureKnownColumns["sequence"] = "hpcc_log_sequence";
+      AzureKnownColumns["threadId"] = "hpcc_log_threadid";
+      AzureKnownColumns["timestamp"] = "hpcc_log_timestamp";
+  })(AzureKnownColumns || (AzureKnownColumns = {}));
+  var RAzureKnownColumns = {};
+  for (var key in AzureKnownColumns) {
+      if (AzureKnownColumns.hasOwnProperty(key)) {
+          RAzureKnownColumns[AzureKnownColumns[key]] = key;
       }
   }
-  var defaultToLogLine = function (line) {
+  var azureToLogLine = function (line) {
+      var _a;
       var retVal = {};
-      for (var key in RKnownColumns) {
-          retVal[RKnownColumns[key]] = line === null || line === void 0 ? void 0 : line.fields[0][key];
+      for (var key in RAzureKnownColumns) {
+          retVal[RAzureKnownColumns[key]] = (_a = line === null || line === void 0 ? void 0 : line.fields[0][key]) !== null && _a !== void 0 ? _a : "";
       }
       return retVal;
   };
@@ -1972,7 +2013,11 @@
           return _super !== null && _super.apply(this, arguments) || this;
       }
       LogaccessService.prototype.GetLogAccessInfo = function (request) {
-          return _super.prototype.GetLogAccessInfo.call(this, request);
+          if (request === void 0) { request = {}; }
+          if (!this._logAccessInfo) {
+              this._logAccessInfo = _super.prototype.GetLogAccessInfo.call(this, request);
+          }
+          return this._logAccessInfo;
       };
       LogaccessService.prototype.GetLogs = function (request) {
           return _super.prototype.GetLogs.call(this, request);
@@ -1999,10 +2044,10 @@
           };
           var filters = [];
           for (var key in request) {
-              if (key in exports.KnownColumns) {
+              if (key in ElasticKnownColumns) {
                   filters.push({
                       LogCategory: exports.WsLogaccess.LogAccessType.ByFieldName,
-                      SearchField: exports.KnownColumns[key],
+                      SearchField: ElasticKnownColumns[key],
                       SearchByValue: request[key]
                   });
               }
@@ -2030,13 +2075,26 @@
               getLogsRequest.Range.StartDate = request.StartDate.toISOString();
               getLogsRequest.Range.EndDate = request.EndDate.toISOString();
           }
-          return this.GetLogs(getLogsRequest).then(function (response) {
-              var _a, _b, _c;
+          return Promise.all([this.GetLogAccessInfo(), this.GetLogs(getLogsRequest)]).then(function (_a) {
+              var _b, _c, _d, _e;
+              var info = _a[0], response = _a[1];
               try {
                   var logLines = JSON.parse(response.LogLines);
+                  var lines = [];
+                  switch (info.RemoteLogManagerType) {
+                      case "azureloganalyticscurl":
+                          lines = (_c = (_b = logLines.lines) === null || _b === void 0 ? void 0 : _b.map(azureToLogLine)) !== null && _c !== void 0 ? _c : [];
+                          break;
+                      case "elasticstack":
+                          lines = (_e = (_d = logLines.lines) === null || _d === void 0 ? void 0 : _d.map(elasticToLogLine)) !== null && _e !== void 0 ? _e : [];
+                          break;
+                      default:
+                          logger$1.warning("Unknown RemoteLogManagerType: ".concat(info.RemoteLogManagerType));
+                          lines = [];
+                  }
                   return {
-                      lines: (_b = (_a = logLines.lines) === null || _a === void 0 ? void 0 : _a.map(defaultToLogLine)) !== null && _b !== void 0 ? _b : [],
-                      total: (_c = response.TotalLogLinesAvailable) !== null && _c !== void 0 ? _c : 10000
+                      lines: lines,
+                      total: response.TotalLogLinesAvailable || 10000
                   };
               }
               catch (e) {
@@ -2498,6 +2556,344 @@
       return TopologyService;
   }(Service));
 
+  var WsWorkunits;
+  (function (WsWorkunits) {
+      (function (ECLWUActions) {
+          ECLWUActions["Abort"] = "Abort";
+          ECLWUActions["Delete"] = "Delete";
+          ECLWUActions["Deschedule"] = "Deschedule";
+          ECLWUActions["Reschedule"] = "Reschedule";
+          ECLWUActions["Pause"] = "Pause";
+          ECLWUActions["PauseNow"] = "PauseNow";
+          ECLWUActions["Protect"] = "Protect";
+          ECLWUActions["Unprotect"] = "Unprotect";
+          ECLWUActions["Restore"] = "Restore";
+          ECLWUActions["Resume"] = "Resume";
+          ECLWUActions["SetToFailed"] = "SetToFailed";
+          ECLWUActions["Archive"] = "Archive";
+      })(WsWorkunits.ECLWUActions || (WsWorkunits.ECLWUActions = {}));
+      (function (EclDefinitionActions) {
+          EclDefinitionActions["SyntaxCheck"] = "SyntaxCheck";
+          EclDefinitionActions["Deploy"] = "Deploy";
+          EclDefinitionActions["Publish"] = "Publish";
+      })(WsWorkunits.EclDefinitionActions || (WsWorkunits.EclDefinitionActions = {}));
+      (function (ErrorMessageFormat) {
+          ErrorMessageFormat["xml"] = "xml";
+          ErrorMessageFormat["json"] = "json";
+          ErrorMessageFormat["text"] = "text";
+      })(WsWorkunits.ErrorMessageFormat || (WsWorkunits.ErrorMessageFormat = {}));
+      (function (LogSelectColumnMode) {
+          LogSelectColumnMode[LogSelectColumnMode["MIN"] = 0] = "MIN";
+          LogSelectColumnMode[LogSelectColumnMode["DEFAULT"] = 1] = "DEFAULT";
+          LogSelectColumnMode[LogSelectColumnMode["ALL"] = 2] = "ALL";
+          LogSelectColumnMode[LogSelectColumnMode["CUSTOM"] = 3] = "CUSTOM";
+      })(WsWorkunits.LogSelectColumnMode || (WsWorkunits.LogSelectColumnMode = {}));
+      (function (LogAccessLogFormat) {
+          LogAccessLogFormat[LogAccessLogFormat["XML"] = 0] = "XML";
+          LogAccessLogFormat[LogAccessLogFormat["JSON"] = 1] = "JSON";
+          LogAccessLogFormat[LogAccessLogFormat["CSV"] = 2] = "CSV";
+      })(WsWorkunits.LogAccessLogFormat || (WsWorkunits.LogAccessLogFormat = {}));
+      (function (WUExceptionSeverity) {
+          WUExceptionSeverity["info"] = "info";
+          WUExceptionSeverity["warning"] = "warning";
+          WUExceptionSeverity["error"] = "error";
+          WUExceptionSeverity["alert"] = "alert";
+      })(WsWorkunits.WUExceptionSeverity || (WsWorkunits.WUExceptionSeverity = {}));
+      (function (WUQueryFilterSuspendedType) {
+          WUQueryFilterSuspendedType["Allqueries"] = "Allqueries";
+          WUQueryFilterSuspendedType["Notsuspended"] = "Notsuspended";
+          WUQueryFilterSuspendedType["Suspended"] = "Suspended";
+          WUQueryFilterSuspendedType["Suspendedbyuser"] = "Suspendedbyuser";
+          WUQueryFilterSuspendedType["Suspendedbyfirstnode"] = "Suspendedbyfirstnode";
+          WUQueryFilterSuspendedType["Suspendedbyanynode"] = "Suspendedbyanynode";
+      })(WsWorkunits.WUQueryFilterSuspendedType || (WsWorkunits.WUQueryFilterSuspendedType = {}));
+      (function (WUQuerySetFilterType) {
+          WUQuerySetFilterType["All"] = "All";
+          WUQuerySetFilterType["Id"] = "Id";
+          WUQuerySetFilterType["Name"] = "Name";
+          WUQuerySetFilterType["Alias"] = "Alias";
+          WUQuerySetFilterType["Status"] = "Status";
+      })(WsWorkunits.WUQuerySetFilterType || (WsWorkunits.WUQuerySetFilterType = {}));
+      (function (WUProtectFilter) {
+          WUProtectFilter["All"] = "All";
+          WUProtectFilter["Protected"] = "Protected";
+          WUProtectFilter["NotProtected"] = "NotProtected";
+      })(WsWorkunits.WUProtectFilter || (WsWorkunits.WUProtectFilter = {}));
+      (function (QuerySetAliasActionTypes) {
+          QuerySetAliasActionTypes["Deactivate"] = "Deactivate";
+      })(WsWorkunits.QuerySetAliasActionTypes || (WsWorkunits.QuerySetAliasActionTypes = {}));
+      (function (QuerysetImportActivation) {
+          QuerysetImportActivation["None"] = "None";
+          QuerysetImportActivation["ActivateImportedActive"] = "ActivateImportedActive";
+      })(WsWorkunits.QuerysetImportActivation || (WsWorkunits.QuerysetImportActivation = {}));
+      (function (QuerySetQueryActionTypes) {
+          QuerySetQueryActionTypes["Suspend"] = "Suspend";
+          QuerySetQueryActionTypes["Unsuspend"] = "Unsuspend";
+          QuerySetQueryActionTypes["ToggleSuspend"] = "ToggleSuspend";
+          QuerySetQueryActionTypes["Activate"] = "Activate";
+          QuerySetQueryActionTypes["Delete"] = "Delete";
+          QuerySetQueryActionTypes["DeleteQueriesAndWUs"] = "DeleteQueriesAndWUs";
+          QuerySetQueryActionTypes["RemoveAllAliases"] = "RemoveAllAliases";
+          QuerySetQueryActionTypes["ResetQueryStats"] = "ResetQueryStats";
+      })(WsWorkunits.QuerySetQueryActionTypes || (WsWorkunits.QuerySetQueryActionTypes = {}));
+      (function (WUQueryActivationMode) {
+          WUQueryActivationMode[WUQueryActivationMode["Donotactivatequery"] = 0] = "Donotactivatequery";
+          WUQueryActivationMode[WUQueryActivationMode["Activatequery"] = 1] = "Activatequery";
+          WUQueryActivationMode[WUQueryActivationMode["Activatequerysuspendprevious"] = 2] = "Activatequerysuspendprevious";
+          WUQueryActivationMode[WUQueryActivationMode["Activatequerydeleteprevious"] = 3] = "Activatequerydeleteprevious";
+      })(WsWorkunits.WUQueryActivationMode || (WsWorkunits.WUQueryActivationMode = {}));
+  })(WsWorkunits || (WsWorkunits = {}));
+  var WorkunitsServiceBase = /** @class */ (function (_super) {
+      __extends(WorkunitsServiceBase, _super);
+      function WorkunitsServiceBase(optsConnection) {
+          return _super.call(this, optsConnection, "WsWorkunits", "1.94") || this;
+      }
+      WorkunitsServiceBase.prototype.GVCAjaxGraph = function (request) {
+          return this._connection.send("GVCAjaxGraph", request, "json", false, undefined, "GVCAjaxGraphResponse");
+      };
+      WorkunitsServiceBase.prototype.Ping = function (request) {
+          return this._connection.send("Ping", request, "json", false, undefined, "WsWorkunitsPingResponse");
+      };
+      WorkunitsServiceBase.prototype.WUAbort = function (request) {
+          return this._connection.send("WUAbort", request, "json", false, undefined, "WUAbortResponse");
+      };
+      WorkunitsServiceBase.prototype.WUAction = function (request) {
+          return this._connection.send("WUAction", request, "json", false, undefined, "WUActionResponse");
+      };
+      WorkunitsServiceBase.prototype.WUAddLocalFileToWorkunit = function (request) {
+          return this._connection.send("WUAddLocalFileToWorkunit", request, "json", false, undefined, "WUAddLocalFileToWorkunitResponse");
+      };
+      WorkunitsServiceBase.prototype.WUAnalyseHotspot = function (request) {
+          return this._connection.send("WUAnalyseHotspot", request, "json", false, undefined, "WUAnalyseHotspotResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCDebug = function (request) {
+          return this._connection.send("WUCDebug", request, "json", false, undefined, "WUDebugResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCheckFeatures = function (request) {
+          return this._connection.send("WUCheckFeatures", request, "json", false, undefined, "WUCheckFeaturesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUClusterJobQueueLOG = function (request) {
+          return this._connection.send("WUClusterJobQueueLOG", request, "json", false, undefined, "WUClusterJobQueueLOGResponse");
+      };
+      WorkunitsServiceBase.prototype.WUClusterJobQueueXLS = function (request) {
+          return this._connection.send("WUClusterJobQueueXLS", request, "json", false, undefined, "WUClusterJobQueueXLSResponse");
+      };
+      WorkunitsServiceBase.prototype.WUClusterJobSummaryXLS = function (request) {
+          return this._connection.send("WUClusterJobSummaryXLS", request, "json", false, undefined, "WUClusterJobSummaryXLSResponse");
+      };
+      WorkunitsServiceBase.prototype.WUClusterJobXLS = function (request) {
+          return this._connection.send("WUClusterJobXLS", request, "json", false, undefined, "WUClusterJobXLSResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCompileECL = function (request) {
+          return this._connection.send("WUCompileECL", request, "json", false, undefined, "WUCompileECLResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCopyLogicalFiles = function (request) {
+          return this._connection.send("WUCopyLogicalFiles", request, "json", false, undefined, "WUCopyLogicalFilesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCopyQuerySet = function (request) {
+          return this._connection.send("WUCopyQuerySet", request, "json", false, undefined, "WUCopyQuerySetResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCreate = function (request) {
+          return this._connection.send("WUCreate", request, "json", false, undefined, "WUCreateResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCreateAndUpdate = function (request) {
+          return this._connection.send("WUCreateAndUpdate", request, "json", false, undefined, "WUUpdateResponse");
+      };
+      WorkunitsServiceBase.prototype.WUCreateZAPInfo = function (request) {
+          return this._connection.send("WUCreateZAPInfo", request, "json", false, undefined, "WUCreateZAPInfoResponse");
+      };
+      WorkunitsServiceBase.prototype.WUDelete = function (request) {
+          return this._connection.send("WUDelete", request, "json", false, undefined, "WUDeleteResponse");
+      };
+      WorkunitsServiceBase.prototype.WUDeployWorkunit = function (request) {
+          return this._connection.send("WUDeployWorkunit", request, "json", false, undefined, "WUDeployWorkunitResponse");
+      };
+      WorkunitsServiceBase.prototype.WUDetails = function (request) {
+          return this._connection.send("WUDetails", request, "json", false, undefined, "WUDetailsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUDetailsMeta = function (request) {
+          return this._connection.send("WUDetailsMeta", request, "json", false, undefined, "WUDetailsMetaResponse");
+      };
+      WorkunitsServiceBase.prototype.WUEclDefinitionAction = function (request) {
+          return this._connection.send("WUEclDefinitionAction", request, "json", false, undefined, "WUEclDefinitionActionResponse");
+      };
+      WorkunitsServiceBase.prototype.WUExport = function (request) {
+          return this._connection.send("WUExport", request, "json", false, undefined, "WUExportResponse");
+      };
+      WorkunitsServiceBase.prototype.WUFile = function (request) {
+          return this._connection.send("WUFile", request, "json", false, undefined, "WULogFileResponse");
+      };
+      WorkunitsServiceBase.prototype.WUFullResult = function (request) {
+          return this._connection.send("WUFullResult", request, "json", false, undefined, "WUFullResultResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGVCGraphInfo = function (request) {
+          return this._connection.send("WUGVCGraphInfo", request, "json", false, undefined, "WUGVCGraphInfoResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetArchiveFile = function (request) {
+          return this._connection.send("WUGetArchiveFile", request, "json", false, undefined, "WUGetArchiveFileResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetDependancyTrees = function (request) {
+          return this._connection.send("WUGetDependancyTrees", request, "json", false, undefined, "WUGetDependancyTreesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetGraph = function (request) {
+          return this._connection.send("WUGetGraph", request, "json", false, undefined, "WUGetGraphResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetGraphNameAndTypes = function (request) {
+          return this._connection.send("WUGetGraphNameAndTypes", request, "json", false, undefined, "WUGetGraphNameAndTypesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetNumFileToCopy = function (request) {
+          return this._connection.send("WUGetNumFileToCopy", request, "json", false, undefined, "WUGetNumFileToCopyResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetPlugins = function (request) {
+          return this._connection.send("WUGetPlugins", request, "json", false, undefined, "WUGetPluginsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetStats = function (request) {
+          return this._connection.send("WUGetStats", request, "json", false, undefined, "WUGetStatsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetThorJobList = function (request) {
+          return this._connection.send("WUGetThorJobList", request, "json", false, undefined, "WUGetThorJobListResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetThorJobQueue = function (request) {
+          return this._connection.send("WUGetThorJobQueue", request, "json", false, undefined, "WUGetThorJobQueueResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGetZAPInfo = function (request) {
+          return this._connection.send("WUGetZAPInfo", request, "json", false, undefined, "WUGetZAPInfoResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGraphInfo = function (request) {
+          return this._connection.send("WUGraphInfo", request, "json", false, undefined, "WUGraphInfoResponse");
+      };
+      WorkunitsServiceBase.prototype.WUGraphTiming = function (request) {
+          return this._connection.send("WUGraphTiming", request, "json", false, undefined, "WUGraphTimingResponse");
+      };
+      WorkunitsServiceBase.prototype.WUInfo = function (request) {
+          return this._connection.send("WUInfo", request, "json", false, undefined, "WUInfoResponse");
+      };
+      WorkunitsServiceBase.prototype.WUInfoDetails = function (request) {
+          return this._connection.send("WUInfoDetails", request, "json", false, undefined, "WUInfoResponse");
+      };
+      WorkunitsServiceBase.prototype.WUJobList = function (request) {
+          return this._connection.send("WUJobList", request, "json", false, undefined, "WUJobListResponse");
+      };
+      WorkunitsServiceBase.prototype.WULightWeightQuery = function (request) {
+          return this._connection.send("WULightWeightQuery", request, "json", false, undefined, "WULightWeightQueryResponse");
+      };
+      WorkunitsServiceBase.prototype.WUListArchiveFiles = function (request) {
+          return this._connection.send("WUListArchiveFiles", request, "json", false, undefined, "WUListArchiveFilesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUListLocalFileRequired = function (request) {
+          return this._connection.send("WUListLocalFileRequired", request, "json", false, undefined, "WUListLocalFileRequiredResponse");
+      };
+      WorkunitsServiceBase.prototype.WUListQueries = function (request) {
+          return this._connection.send("WUListQueries", request, "json", false, undefined, "WUListQueriesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUListQueriesUsingFile = function (request) {
+          return this._connection.send("WUListQueriesUsingFile", request, "json", false, undefined, "WUListQueriesUsingFileResponse");
+      };
+      WorkunitsServiceBase.prototype.WUMultiQuerysetDetails = function (request) {
+          return this._connection.send("WUMultiQuerysetDetails", request, "json", false, undefined, "WUMultiQuerySetDetailsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUProcessGraph = function (request) {
+          return this._connection.send("WUProcessGraph", request, "json", false, undefined, "WUProcessGraphResponse");
+      };
+      WorkunitsServiceBase.prototype.WUProtect = function (request) {
+          return this._connection.send("WUProtect", request, "json", false, undefined, "WUProtectResponse");
+      };
+      WorkunitsServiceBase.prototype.WUPublishWorkunit = function (request) {
+          return this._connection.send("WUPublishWorkunit", request, "json", false, undefined, "WUPublishWorkunitResponse");
+      };
+      WorkunitsServiceBase.prototype.WUPushEvent = function (request) {
+          return this._connection.send("WUPushEvent", request, "json", false, undefined, "WUPushEventResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuery = function (request) {
+          return this._connection.send("WUQuery", request, "json", false, undefined, "WUQueryResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQueryConfig = function (request) {
+          return this._connection.send("WUQueryConfig", request, "json", false, undefined, "WUQueryConfigResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQueryDetails = function (request) {
+          return this._connection.send("WUQueryDetails", request, "json", false, undefined, "WUQueryDetailsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQueryDetailsLightWeight = function (request) {
+          return this._connection.send("WUQueryDetailsLightWeight", request, "json", false, undefined, "WUQueryDetailsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQueryFiles = function (request) {
+          return this._connection.send("WUQueryFiles", request, "json", false, undefined, "WUQueryFilesResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQueryGetGraph = function (request) {
+          return this._connection.send("WUQueryGetGraph", request, "json", false, undefined, "WUQueryGetGraphResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQueryGetSummaryStats = function (request) {
+          return this._connection.send("WUQueryGetSummaryStats", request, "json", false, undefined, "WUQueryGetSummaryStatsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysetAliasAction = function (request) {
+          return this._connection.send("WUQuerysetAliasAction", request, "json", false, undefined, "WUQuerySetAliasActionResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysetCopyQuery = function (request) {
+          return this._connection.send("WUQuerysetCopyQuery", request, "json", false, undefined, "WUQuerySetCopyQueryResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysetDetails = function (request) {
+          return this._connection.send("WUQuerysetDetails", request, "json", false, undefined, "WUQuerySetDetailsResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysetExport = function (request) {
+          return this._connection.send("WUQuerysetExport", request, "json", false, undefined, "WUQuerysetExportResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysetImport = function (request) {
+          return this._connection.send("WUQuerysetImport", request, "json", false, undefined, "WUQuerysetImportResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysetQueryAction = function (request) {
+          return this._connection.send("WUQuerysetQueryAction", request, "json", false, undefined, "WUQuerySetQueryActionResponse");
+      };
+      WorkunitsServiceBase.prototype.WUQuerysets = function (request) {
+          return this._connection.send("WUQuerysets", request, "json", false, undefined, "WUQuerysetsResponse");
+      };
+      WorkunitsServiceBase.prototype.WURecreateQuery = function (request) {
+          return this._connection.send("WURecreateQuery", request, "json", false, undefined, "WURecreateQueryResponse");
+      };
+      WorkunitsServiceBase.prototype.WUResubmit = function (request) {
+          return this._connection.send("WUResubmit", request, "json", false, undefined, "WUResubmitResponse");
+      };
+      WorkunitsServiceBase.prototype.WUResult = function (request) {
+          return this._connection.send("WUResult", request, "json", false, undefined, "WUResultResponse");
+      };
+      WorkunitsServiceBase.prototype.WUResultBin = function (request) {
+          return this._connection.send("WUResultBin", request, "json", false, undefined, "WUResultBinResponse");
+      };
+      WorkunitsServiceBase.prototype.WUResultSummary = function (request) {
+          return this._connection.send("WUResultSummary", request, "json", false, undefined, "WUResultSummaryResponse");
+      };
+      WorkunitsServiceBase.prototype.WUResultView = function (request) {
+          return this._connection.send("WUResultView", request, "json", false, undefined, "WUResultViewResponse");
+      };
+      WorkunitsServiceBase.prototype.WURun = function (request) {
+          return this._connection.send("WURun", request, "json", false, undefined, "WURunResponse");
+      };
+      WorkunitsServiceBase.prototype.WUSchedule = function (request) {
+          return this._connection.send("WUSchedule", request, "json", false, undefined, "WUScheduleResponse");
+      };
+      WorkunitsServiceBase.prototype.WUShowScheduled = function (request) {
+          return this._connection.send("WUShowScheduled", request, "json", false, undefined, "WUShowScheduledResponse");
+      };
+      WorkunitsServiceBase.prototype.WUSubmit = function (request) {
+          return this._connection.send("WUSubmit", request, "json", false, undefined, "WUSubmitResponse");
+      };
+      WorkunitsServiceBase.prototype.WUSyntaxCheckECL = function (request) {
+          return this._connection.send("WUSyntaxCheckECL", request, "json", false, undefined, "WUSyntaxCheckResponse");
+      };
+      WorkunitsServiceBase.prototype.WUUpdate = function (request) {
+          return this._connection.send("WUUpdate", request, "json", false, undefined, "WUUpdateResponse");
+      };
+      WorkunitsServiceBase.prototype.WUUpdateQueryEntry = function (request) {
+          return this._connection.send("WUUpdateQueryEntry", request, "json", false, undefined, "WUUpdateQueryEntryResponse");
+      };
+      WorkunitsServiceBase.prototype.WUWaitCompiled = function (request) {
+          return this._connection.send("WUWaitCompiled", request, "json", false, undefined, "WUWaitResponse");
+      };
+      WorkunitsServiceBase.prototype.WUWaitComplete = function (request) {
+          return this._connection.send("WUWaitComplete", request, "json", false, undefined, "WUWaitResponse");
+      };
+      return WorkunitsServiceBase;
+  }(Service));
+
   /*
       Response structures generated via:
       * http://localhost:8010/WsWorkunits/WUInfo?reqjson_
@@ -2661,6 +3057,13 @@
       };
       return WorkunitsService;
   }(Service));
+  var WorkunitsServiceEx = /** @class */ (function (_super) {
+      __extends(WorkunitsServiceEx, _super);
+      function WorkunitsServiceEx() {
+          return _super !== null && _super.apply(this, arguments) || this;
+      }
+      return WorkunitsServiceEx;
+  }(WorkunitsServiceBase));
 
   var t0 = new Date,
       t1 = new Date;
@@ -2748,6 +3151,7 @@
   });
 
   var timeDay = day;
+  day.range;
 
   function weekday(i) {
     return newInterval(function(date) {
@@ -2762,11 +3166,19 @@
 
   var sunday = weekday(0);
   var monday = weekday(1);
-  weekday(2);
-  weekday(3);
+  var tuesday = weekday(2);
+  var wednesday = weekday(3);
   var thursday = weekday(4);
-  weekday(5);
-  weekday(6);
+  var friday = weekday(5);
+  var saturday = weekday(6);
+
+  sunday.range;
+  monday.range;
+  tuesday.range;
+  wednesday.range;
+  thursday.range;
+  friday.range;
+  saturday.range;
 
   var year = newInterval(function(date) {
     date.setMonth(0, 1);
@@ -2791,6 +3203,7 @@
   };
 
   var timeYear = year;
+  year.range;
 
   var utcDay = newInterval(function(date) {
     date.setUTCHours(0, 0, 0, 0);
@@ -2803,6 +3216,7 @@
   });
 
   var utcDay$1 = utcDay;
+  utcDay.range;
 
   function utcWeekday(i) {
     return newInterval(function(date) {
@@ -2817,11 +3231,19 @@
 
   var utcSunday = utcWeekday(0);
   var utcMonday = utcWeekday(1);
-  utcWeekday(2);
-  utcWeekday(3);
+  var utcTuesday = utcWeekday(2);
+  var utcWednesday = utcWeekday(3);
   var utcThursday = utcWeekday(4);
-  utcWeekday(5);
-  utcWeekday(6);
+  var utcFriday = utcWeekday(5);
+  var utcSaturday = utcWeekday(6);
+
+  utcSunday.range;
+  utcMonday.range;
+  utcTuesday.range;
+  utcWednesday.range;
+  utcThursday.range;
+  utcFriday.range;
+  utcSaturday.range;
 
   var utcYear = newInterval(function(date) {
     date.setUTCMonth(0, 1);
@@ -2846,6 +3268,7 @@
   };
 
   var utcYear$1 = utcYear;
+  utcYear.range;
 
   function localDate(d) {
     if (0 <= d.y && d.y < 100) {
@@ -3551,6 +3974,8 @@
 
   function defaultLocale(definition) {
     locale = formatLocale(definition);
+    locale.format;
+    locale.parse;
     utcFormat = locale.utcFormat;
     utcParse = locale.utcParse;
     return locale;
@@ -4283,18 +4708,19 @@
       Result.prototype.isComplete = function () {
           return this.Total !== -1;
       };
-      Result.prototype.fetchXMLSchema = function () {
+      Result.prototype.fetchXMLSchema = function (refresh) {
           var _this = this;
-          if (this.xsdSchema) {
-              return Promise.resolve(this.xsdSchema);
+          if (refresh === void 0) { refresh = false; }
+          if (!this._fetchXMLSchemaPromise || refresh) {
+              this._fetchXMLSchemaPromise = this.WUResult().then(function (response) {
+                  if (util.exists("Result.XmlSchema.xml", response)) {
+                      _this.xsdSchema = parseXSD(response.Result.XmlSchema.xml);
+                      return _this.xsdSchema;
+                  }
+                  return null;
+              });
           }
-          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;
-          });
+          return this._fetchXMLSchemaPromise;
       };
       Result.prototype.refresh = function () {
           return __awaiter(this, void 0, void 0, function () {
@@ -6563,6 +6989,11 @@
           enumerable: false,
           configurable: true
       });
+      Object.defineProperty(LogicalFile.prototype, "ExpirationDate", {
+          get: function () { return this.get("ExpirationDate"); },
+          enumerable: false,
+          configurable: true
+      });
       Object.defineProperty(LogicalFile.prototype, "properties", {
           get: function () { return this.get(); },
           enumerable: false,
@@ -7533,6 +7964,10 @@
   exports.CloudService = CloudService;
   exports.CodesignService = CodesignService;
   exports.Connection = Connection;
+  exports.DFUArrayActions = DFUArrayActions;
+  exports.DFUChangeProtection = DFUChangeProtection;
+  exports.DFUChangeRestriction = DFUChangeRestriction;
+  exports.DFUDefFileFormat = DFUDefFileFormat;
   exports.DFUService = DFUService;
   exports.DFUXRefService = DFUXRefService;
   exports.DaliService = DaliService;
@@ -7579,6 +8014,7 @@
   exports.Workunit = Workunit;
   exports.WorkunitCache = WorkunitCache;
   exports.WorkunitsService = WorkunitsService;
+  exports.WorkunitsServiceEx = WorkunitsServiceEx;
   exports.XGMMLEdge = XGMMLEdge;
   exports.XGMMLGraph = XGMMLGraph;
   exports.XGMMLSubgraph = XGMMLSubgraph;