text: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You 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
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var baseURL;
  if (location.host.indexOf('/') == -1 && location.protocol.indexOf('/') == -1) {
      baseURL = location.protocol + "//" + location.host + "/";
  }else if(location.host.indexOf('/') != -1 && location.protocol.indexOf('/') == -1){
      baseURL = location.protocol + "//" + location.host;
  }
  var baseDirectoryName = location.pathname.substring(0,location.pathname.indexOf('/',1));
  if(baseDirectoryName.indexOf('/') == 0){
      baseDirectoryName = baseDirectoryName.substring(1);
  }
  var address = baseURL + baseDirectoryName + "/processes/ProcessManagement";
  //var address = baseURL + "ode/processes/ProcessManagement";
  
  var ProcessManagementService = new WebServiceClient("ProcessManagementPort");
  
  ProcessManagementService.getExtensibilityElements = function getExtensibilityElements(/* aidsType */ _aids, /* QName */ _pid) {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.getExtensibilityElements.callback != null && typeof(this.getExtensibilityElements.callback) == 'function');
      request =
      '<p:getExtensibilityElements xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_aids == null ? '' : '<aids>' + _aids + '</aids>') +
      (_pid == null ? '' : '<pid>' + this._encodeXML(_pid) + '</pid>') +
      '</p:getExtensibilityElements>';
  
      if (isAsync) {
          try {
              this._call(
                      "getExtensibilityElements",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.getExtensibilityElements.callback, this.getExtensibilityElements.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.getExtensibilityElements.onError(error);
          }
      } else {
          try {
              response = this._call("getExtensibilityElements", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.getExtensibilityElements.callback = null;
  
  ProcessManagementService.activate =
  function activate(/* String */ _name, /* String */ _nmspURL, /* String */ _prefix)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.activate.callback != null && typeof(this.activate.callback) == 'function');
      request =
      '<p:activate xmlns:p="http://www.apache.org/ode/pmapi">' +
      ((_name != null && _nmspURL != null && _prefix != null) ? '<pid xmlns:' + this._encodeXML(_prefix) + '="' + this._encodeXML(_nmspURL) + '">' +
                                                                this._encodeXML(_prefix) + ':' + this._encodeXML(_name) + '</pid>' : '') +
      '</p:activate>';
  
      if (isAsync) {
          try {
              this._call(
                      "activate",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.activate.callback, this.activate.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.activate.onError(error);
          }
      } else {
          try {
              response = this._call("activate", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.activate.callback = null;
  
  ProcessManagementService.setProcessProperty =
  function setProcessProperty(/* QName */ _propertyName, /* string */ _propertyValue, /* QName */ _pid)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.setProcessProperty.callback != null && typeof(this.setProcessProperty.callback) == 'function');
      request =
      '<p:setProcessProperty xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_propertyName == null ? '' : '<propertyName>' + this._encodeXML(_propertyName) + '</propertyName>') +
      (_propertyValue == null ? '' : '<propertyValue>' + this._encodeXML(_propertyValue) + '</propertyValue>') +
      (_pid == null ? '' : '<pid>' + this._encodeXML(_pid) + '</pid>') +
      '</p:setProcessProperty>';
  
      if (isAsync) {
          try {
              this._call(
                      "setProcessProperty",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.setProcessProperty.callback, this.setProcessProperty.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.setProcessProperty.onError(error);
          }
      } else {
          try {
              response = this._call("setProcessProperty", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.setProcessProperty.callback = null;
  
  ProcessManagementService.getProcessInfoCustom =
  function getProcessInfoCustom(/* string */ _customizer, /* QName */ _pid)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.getProcessInfoCustom.callback != null && typeof(this.getProcessInfoCustom.callback) == 'function');
      request =
      '<p:getProcessInfoCustom xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_customizer == null ? '' : '<customizer>' + this._encodeXML(_customizer) + '</customizer>') +
      (_pid == null ? '' : '<pid>' + this._encodeXML(_pid) + '</pid>') +
      '</p:getProcessInfoCustom>';
  
      if (isAsync) {
          try {
              this._call(
                      "getProcessInfoCustom",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.getProcessInfoCustom.callback, this.getProcessInfoCustom.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.getProcessInfoCustom.onError(error);
          }
      } else {
          try {
              response = this._call("getProcessInfoCustom", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.getProcessInfoCustom.callback = null;
  
  ProcessManagementService.listProcessesCustom =
  function listProcessesCustom(/* string */ _filter, /* string */ _customizer, /* string */ _orderKeys)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.listProcessesCustom.callback != null && typeof(this.listProcessesCustom.callback) == 'function');
      request =
      '<p:listProcessesCustom xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_filter == null ? '' : '<filter>' + this._encodeXML(_filter) + '</filter>') +
      (_customizer == null ? '' : '<customizer>' + this._encodeXML(_customizer) + '</customizer>') +
      (_orderKeys == null ? '' : '<orderKeys>' + this._encodeXML(_orderKeys) + '</orderKeys>') +
      '</p:listProcessesCustom>';
  
      if (isAsync) {
          try {
              this._call(
                      "listProcessesCustom",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfoList */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.listProcessesCustom.callback, this.listProcessesCustom.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.listProcessesCustom.onError(error);
          }
      } else {
          try {
              response = this._call("listProcessesCustom", request);
              resultValue = /* tProcessInfoList */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.listProcessesCustom.callback = null;
  
  ProcessManagementService.getProcessInfo =
  function getProcessInfo(/* String */ _name, /* String */ _nmspURL, /* String */ _prefix)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.getProcessInfo.callback != null && typeof(this.getProcessInfo.callback) == 'function');
      request =
      '<p:getProcessInfo xmlns:p="http://www.apache.org/ode/pmapi">' +
      ((_name != null && _nmspURL != null && _prefix != null) ? '<pid xmlns:' + this._encodeXML(_prefix) + '="' + this._encodeXML(_nmspURL) + '">' +
                                                                this._encodeXML(_prefix) + ':' + this._encodeXML(_name) + '</pid>' : '') +
      '</p:getProcessInfo>';
  
      if (isAsync) {
          try {
              this._call(
                      "getProcessInfo",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.getProcessInfo.callback, this.getProcessInfo.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.getProcessInfo.onError(error);
          }
      } else {
          try {
              response = this._call("getProcessInfo", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.getProcessInfo.callback = null;
  
  ProcessManagementService.listProcesses =
  function listProcesses(/* string */ _filter, /* string */ _orderKeys)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.listProcesses.callback != null && typeof(this.listProcesses.callback) == 'function');
      request =
      '<p:listProcesses xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_filter == null ? '' : '<filter>' + this._encodeXML(_filter) + '</filter>') +
      (_orderKeys == null ? '' : '<orderKeys>' + this._encodeXML(_orderKeys) + '</orderKeys>') +
      '</p:listProcesses>';
  
      if (isAsync) {
          try {
              this._call(
                      "listProcesses",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfoList */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.listProcesses.callback, this.listProcesses.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.listProcesses.onError(error);
          }
      } else {
          try {
              response = this._call("listProcesses", request);
              resultValue = /* tProcessInfoList */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.listProcesses.callback = null;
  
  ProcessManagementService.setRetired =
  function setRetired(/* boolean */ _retired, /* String */ _name, /* String */ _nmspURL, /* String */ _prefix)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.setRetired.callback != null && typeof(this.setRetired.callback) == 'function');
      request =
      '<p:setRetired xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_retired == null ? '' : '<retired>' + this._encodeXML(_retired) + '</retired>') +
      ((_name != null && _nmspURL != null && _prefix != null) ? '<pid xmlns:' + this._encodeXML(_prefix) + '="' + this._encodeXML(_nmspURL) + '">' +
                                                                this._encodeXML(_prefix) + ':' + this._encodeXML(_name) + '</pid>' : '') +
      '</p:setRetired>';
  
      if (isAsync) {
          try {
              this._call(
                      "setRetired",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.setRetired.callback, this.setRetired.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.setRetired.onError(error);
          }
      } else {
          try {
              response = this._call("setRetired", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.setRetired.callback = null;
  
  ProcessManagementService.setProcessPropertyNode =
  function setProcessPropertyNode(/* QName */ _propertyName, /* anyType */ _propertyValue, /* QName */ _pid)
  {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.setProcessPropertyNode.callback != null && typeof(this.setProcessPropertyNode.callback) == 'function');
      request =
      '<p:setProcessPropertyNode xmlns:p="http://www.apache.org/ode/pmapi">' +
      (_propertyName == null ? '' : '<propertyName>' + this._encodeXML(_propertyName) + '</propertyName>') +
      (_propertyValue == null ? '' : '<propertyValue>' + _propertyValue + '</propertyValue>') +
      (_pid == null ? '' : '<pid>' + this._encodeXML(_pid) + '</pid>') +
      '</p:setProcessPropertyNode>';
  
      if (isAsync) {
          try {
              this._call(
                      "setProcessPropertyNode",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfo */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.setProcessPropertyNode.callback, this.setProcessPropertyNode.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.setProcessPropertyNode.onError(error);
          }
      } else {
          try {
              response = this._call("setProcessPropertyNode", request);
              resultValue = /* tProcessInfo */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.setProcessPropertyNode.callback = null;
  
  ProcessManagementService.listAllProcesses = function listAllProcesses() {
      var isAsync, request, response, resultValue;
  
      this._options = new Array();
      isAsync = (this.listAllProcesses.callback != null && typeof(this.listAllProcesses.callback) == 'function');
      request =
      '<p:listAllProcesses xmlns:p="http://www.apache.org/ode/pmapi">' +
      '</p:listAllProcesses>';
  
      if (isAsync) {
          try {
              this._call(
                      "listAllProcesses",
                      request,
                      function(thisRequest, callbacks) {
                          if (thisRequest.error != null) {
                              callbacks[1](thisRequest.error);
                          } else {
                              response = thisRequest.responseXML;
                              if (response == null) {
                                  resultValue = null;
                              } else {
                                  resultValue = /* tProcessInfoList */ response.documentElement;
                              }
                              callbacks[0](resultValue);
                          }
                      },
                      new Array(this.listAllProcesses.callback, this.listAllProcesses.onError)
                      );
          } catch (e) {
              var error;
              if (WebServiceError.prototype.isPrototypeOf(e)) {
                  error = e;
              } else if (typeof(e) == "string") {
                  error = new WebServiceError(e, "Internal Error");
              } else {
                  error = new WebServiceError(e.description, e.number, e.number);
              }
              this.listAllProcesses.onError(error);
          }
      } else {
          try {
              response = this._call("listAllProcesses", request);
              resultValue = /* tProcessInfoList */ response.documentElement;
              return resultValue;
          } catch (e) {
              if (typeof(e) == "string") throw(e);
              if (e.message) throw(e.message);
              throw (e.reason + e.detail);
          }
      }
      return null; // Suppress warnings when there is no return.
  }
  ProcessManagementService.listAllProcesses.callback = null;
  
  
  
  // WebService object.
  function WebServiceClient(endpointName)
  {
      this.readyState = 0;
      this.onreadystatechange = null;
  
      //public accessors for manually intervening in setting the address (e.g. supporting tcpmon)
      this.getAddress = function (endpointName)
      {
          return this._endpointDetails[endpointName].address;
      }
  
      this.setAddress = function (endpointName, address)
      {
          this._endpointDetails[endpointName].address = address;
      }
  
      // private helper functions
      this._getWSRequest = function()
      {
          var wsrequest;
          try {
              wsrequest = new WSRequest();
          } catch(e) {
              try {
                  wsrequest = new ActiveXObject("WSRequest");
              } catch(e) {
                  try {
                      wsrequest = new SOAPHttpRequest();
                      netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
                  } catch (e) {
                      throw new WebServiceError("WSRequest object not defined.", "WebServiceClient._getWSRequest() cannot instantiate WSRequest object.");
                  }
              }
          }
          return wsrequest;
      }
  
      this._endpointDetails =
      {
          "ProcessManagementPort": {
              "type" : "SOAP11",
              "address" : address,
              "action" : {
                  "getExtensibilityElements" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/getExtensibilityElementsRequest",
                  "activate" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/activateRequest",
                  "setProcessProperty" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/setProcessPropertyRequest",
                  "getProcessInfoCustom" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/getProcessInfoCustomRequest",
                  "listProcessesCustom" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/listProcessesCustomRequest",
                  "getProcessInfo" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/getProcessInfoRequest",
                  "listProcesses" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/listProcessesRequest",
                  "setRetired" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/setRetiredRequest",
                  "setProcessPropertyNode" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/setProcessPropertyNodeRequest",
                  "listAllProcesses" : "http://www.apache.org/ode/pmapi/ProcessManagementPortType/listAllProcessesRequest"
              }
          }
      };
      this.endpoint = endpointName;
  
      this._encodeXML = function (value) {
          var re;
          var str = value.toString();
          re = /&/g;
          str = str.replace(re, "&amp;");
          re = /</g;
          str = str.replace(re, "&lt;");
          return(str);
      };
  
      this._call = function (opName, reqContent, callback, userdata)
      {
          var details = this._endpointDetails[this.endpoint];
          if (details.type == 'SOAP12') this._options.useSOAP = 1.2;
          else if (details.type == 'SOAP11') this._options.useSOAP = 1.1;
          else if (details.type == 'HTTP') this._options.useSOAP = false;
  
          if (details.action != null) {
              this._options.useWSA = true;
              this._options.action = details.action[opName];
          } else if (details.soapaction != null) {
              this._options.useWSA = false;
              this._options.action = details.soapaction[opName];
          } else {
              this._options.useWSA = false;
              this._options.action = undefined;
          }
  
          if (details["httpmethod"] != null) {
              this._options.HTTPMethod = details.httpmethod[opName];
          } else {
              this._options.HTTPMethod = null;
          }
  
          if (details["httpinputSerialization"] != null) {
              this._options.HTTPInputSerialization = details.httpinputSerialization[opName];
          } else {
              this._options.HTTPInputSerialization = null;
          }
  
          if (details["httplocation"] != null) {
              this._options.HTTPLocation = details.httplocation[opName];
          } else {
              this._options.HTTPLocation = null;
          }
  
          if (details["httpignoreUncited"] != null) {
              this._options.HTTPLocationIgnoreUncited = details.httpignoreUncited[opName];
          } else {
              this._options.HTTPLocationIgnoreUncited = null;
          }
  
          if (details["httpqueryParameterSeparator"] != null) {
              this._options.HTTPQueryParameterSeparator = details.httpqueryParameterSeparator[opName];
          } else {
              this._options.HTTPQueryParameterSeparator = null;
          }
  
          var isAsync = (typeof(callback) == 'function');
  
          var thisRequest = this._getWSRequest();
          if (isAsync) {
              thisRequest._userdata = userdata;
              thisRequest.onreadystatechange =
              function() {
                  if (thisRequest.readyState == 4) {
                      callback(thisRequest, userdata);
                  }
              }
          }
          thisRequest.open(this._options, details.address, isAsync);
          thisRequest.send(reqContent);
          if (isAsync) {
              return "";
          } else {
              try {
                  var resultContent = thisRequest.responseText;
                  ProcessManagementService.text = resultContent;
                  if (resultContent == "") {
                      throw new WebServiceError("No response", "WebServiceClient._call() did not recieve a response to a synchronous request.");
                  }
                  var resultXML = thisRequest.responseXML;
              } catch (e) {
                  throw new WebServiceError(e);
              }
              return resultXML;
          }
      }
  }
  WebServiceClient.visible = false;
  
  // library function for dynamically converting an element with js:type annotation to a Javascript type.
  convertJSType.visible = false;
  function convertJSType(element, isWrapped) {
      if (element == null) return "";
      var extractedValue = WSRequest.util._stringValue(element);
      var resultValue, i;
      var type = element.getAttribute("js:type");
      if (type == null) {
          type = "xml";
      } else {
          type = type.toString();
      }
      switch (type) {
          case "string":
              return extractedValue;
              break;
          case "number":
              return parseFloat(extractedValue);
              break;
          case "boolean":
              return extractedValue == "true" || extractedValue == "1";
              break;
          case "date":
              return xs_dateTime_to_date(extractedValue);
              break;
          case "array":
              resultValue = new Array();
              for (i = 0; i < element.childNodes.length; i++) {
                  resultValue = resultValue.concat(convertJSType(element.childNodes[i]));
              }
              return(resultValue);
              break;
          case "object":
              resultValue = new Object();
              for (i = 0; i < element.childNodes.length; i++) {
                  resultValue[element.childNodes[i].tagName] = convertJSType(element.childNodes[i]);
              }
              return(resultValue);
              break;
          case "xmllist":
              return element.childNodes;
              break;
          case "xml":
          default:
              if (isWrapped == true)
                  return element.firstChild;
              else return element;
              break;
      }
  }
  
  // library function for parsing xs:date, xs:time, and xs:dateTime types into Date objects.
  function xs_dateTime_to_date(dateTime)
  {
      var buffer = dateTime;
      var p = 0; // pointer to current parse location in buffer.
  
      var era, year, month, day, hour, minute, second, millisecond;
  
      // parse date, if there is one.
      if (buffer.substr(p, 1) == '-')
      {
          era = -1;
          p++;
      } else {
          era = 1;
      }
  
      if (buffer.charAt(p + 2) != ':')
      {
          year = era * buffer.substr(p, 4);
          p += 5;
          month = buffer.substr(p, 2);
          p += 3;
          day = buffer.substr(p, 2);
          p += 3;
      } else {
          year = 1970;
          month = 1;
          day = 1;
      }
  
      // parse time, if there is one
      if (buffer.charAt(p) != '+' && buffer.charAt(p) != '-')
      {
          hour = buffer.substr(p, 2);
          p += 3;
          minute = buffer.substr(p, 2);
          p += 3;
          second = buffer.substr(p, 2);
          p += 2;
          if (buffer.charAt(p) == '.')
          {
              millisecond = parseFloat(buffer.substr(p)) * 1000;
              // Note that JS fractional seconds are significant to 3 places - xs:time is significant to more -
              // though implementations are only required to carry 3 places.
              p++;
              while (buffer.charCodeAt(p) >= 48 && buffer.charCodeAt(p) <= 57) p++;
          } else {
              millisecond = 0;
          }
      } else {
          hour = 0;
          minute = 0;
          second = 0;
          millisecond = 0;
      }
  
      var tzhour = 0;
      var tzminute = 0;
      // parse time zone
      if (buffer.charAt(p) != 'Z' && buffer.charAt(p) != '') {
          var sign = (buffer.charAt(p) == '-' ? -1 : +1);
          p++;
          tzhour = sign * buffer.substr(p, 2);
          p += 3;
          tzminute = sign * buffer.substr(p, 2);
      }
  
      var thisDate = new Date();
      thisDate.setUTCFullYear(year);
      thisDate.setUTCMonth(month - 1);
      thisDate.setUTCDate(day);
      thisDate.setUTCHours(hour);
      thisDate.setUTCMinutes(minute);
      thisDate.setUTCSeconds(second);
      thisDate.setUTCMilliseconds(millisecond);
      thisDate.setUTCHours(thisDate.getUTCHours() - tzhour);
      thisDate.setUTCMinutes(thisDate.getUTCMinutes() - tzminute);
      return thisDate;
  }
  xs_dateTime_to_date.visible = false;
  
  function scheme(url) {
      var s = url.substring(0, url.indexOf(':'));
      return s;
  }
  scheme.visible = false;
  
  function domain(url) {
      var d = url.substring(url.indexOf('://') + 3, url.indexOf('/', url.indexOf('://') + 3));
      return d;
  }
  domain.visible = false;
  
  function domainNoPort(url) {
      var d = domain(url);
      if (d.indexOf(":") >= 0)
          d = d.substring(0, d.indexOf(':'));
      return d;
  }
  domainNoPort.visible = false;
  
  try {
      var secureEndpoint = "";
      var pageUrl = document.URL;
      var pageScheme = scheme(pageUrl);
      // only attempt fixup if we're from an http/https domain ('file:' works fine on IE without fixup)
      if (pageScheme == "http" || pageScheme == "https") {
          var pageDomain = domain(pageUrl);
          var pageDomainNoPort = domainNoPort(pageUrl);
          var endpoints = ProcessManagementService._endpointDetails;
          // loop through each available endpoint
          for (var i in endpoints) {
              var address = endpoints[i].address;
              // if we're in a secure domain, set the endpoint to the first secure endpoint we come across
              if (secureEndpoint == "" && pageScheme == "https" && scheme(address) == "https") {
                  secureEndpoint = i;
                  ProcessManagementService.endpoint = secureEndpoint;
              }
              // if we're in a known localhost domain, rewrite the endpoint domain so that we won't get
              //  a bogus xss violation
              if (pageDomainNoPort.indexOf('localhost') == 0 || pageDomainNoPort.indexOf('127.0.0.1') == 0) {
                  endpoints[i].address = address.replace(domainNoPort(address), pageDomainNoPort);
              }
          }
      }
  } catch (e) {
  }
  
  