soap 1.4.1 → 1.5.0

package/Readme.md

@@ -4,7 +4,7 @@
 
 # SOAP client and server for node.js.
 
-This module lets you connect to web services using SOAP.  It also provides a server that allows you to run your own SOAP services.
+This module lets you connect to web services using SOAP. It also provides a server that allows you to run your own SOAP services.
 
 <!-- Run `npm run toc` to update below section -->
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
@@ -16,8 +16,8 @@ This module lets you connect to web services using SOAP.  It also provides a ser
 - [Module](#module)
   - [soap.createClient(url[, options], callback) - create a new SOAP client from a WSDL url. Also supports a local filesystem path.](#soapcreateclienturl-options-callback---create-a-new-soap-client-from-a-wsdl-url-also-supports-a-local-filesystem-path)
   - [soap.createClientAsync(url[, options]) - create a new SOAP client from a WSDL url. Also supports a local filesystem path.](#soapcreateclientasyncurl-options---create-a-new-soap-client-from-a-wsdl-url-also-supports-a-local-filesystem-path)
-  - [soap.listen(*server*, *path*, *services*, *wsdl*, *callback*) - create a new SOAP server that listens on *path* and provides *services*.](#soaplistenserver-path-services-wsdl-callback---create-a-new-soap-server-that-listens-on-path-and-provides-services)
-  - [soap.listen(*server*, *options*) - create a new SOAP server that listens on *path* and provides *services*.](#soaplistenserver-options---create-a-new-soap-server-that-listens-on-path-and-provides-services)
+  - [soap.listen(_server_, _path_, _services_, _wsdl_, _callback_) - create a new SOAP server that listens on _path_ and provides _services_.](#soaplistenserver-path-services-wsdl-callback---create-a-new-soap-server-that-listens-on-path-and-provides-services)
+  - [soap.listen(_server_, _options_) - create a new SOAP server that listens on _path_ and provides _services_.](#soaplistenserver-options---create-a-new-soap-server-that-listens-on-path-and-provides-services)
   - [Server Logging](#server-logging)
   - [Server Events](#server-events)
   - [Server Response on one-way calls](#server-response-on-one-way-calls)
@@ -30,11 +30,11 @@ This module lets you connect to web services using SOAP.  It also provides a ser
 - [Client](#client)
   - [Client.describe() - description of services, ports and methods as a JavaScript object](#clientdescribe---description-of-services-ports-and-methods-as-a-javascript-object)
   - [Client.setSecurity(security) - use the specified security protocol](#clientsetsecuritysecurity---use-the-specified-security-protocol)
-  - [Client.*method*(args, callback, options) - call *method* on the SOAP service.](#clientmethodargs-callback-options---call-method-on-the-soap-service)
-  - [Client.*method*Async(args, options) - call *method* on the SOAP service.](#clientmethodasyncargs-options---call-method-on-the-soap-service)
-  - [Client.*service*.*port*.*method*(args, callback[, options[, extraHeaders]]) - call a *method* using a specific *service* and *port*](#clientserviceportmethodargs-callback-options-extraheaders---call-a-method-using-a-specific-service-and-port)
+  - [Client._method_(args, callback, options) - call _method_ on the SOAP service.](#clientmethodargs-callback-options---call-method-on-the-soap-service)
+  - [Client.*method*Async(args, options) - call _method_ on the SOAP service.](#clientmethodasyncargs-options---call-method-on-the-soap-service)
+  - [Client._service_._port_._method_(args, callback[, options[, extraHeaders]]) - call a _method_ using a specific _service_ and _port_](#clientserviceportmethodargs-callback-options-extraheaders---call-a-method-using-a-specific-service-and-port)
   - [Overriding the namespace prefix](#overriding-the-namespace-prefix)
-  - [Client.*lastRequest* - the property that contains last full soap request for client logging](#clientlastrequest---the-property-that-contains-last-full-soap-request-for-client-logging)
+  - [Client._lastRequest_ - the property that contains last full soap request for client logging](#clientlastrequest---the-property-that-contains-last-full-soap-request-for-client-logging)
   - [Client.setEndpoint(url) - overwrite the SOAP service endpoint address](#clientsetendpointurl---overwrite-the-soap-service-endpoint-address)
   - [Client Events](#client-events)
   - [_request_](#_request_)
@@ -67,20 +67,18 @@ This module lets you connect to web services using SOAP.  It also provides a ser
   - [Changing the tag formats to use self-closing (empty element) tags](#changing-the-tag-formats-to-use-self-closing-empty-element-tags)
 - [Handling "ignored" namespaces](#handling-ignored-namespaces)
 - [Handling "ignoreBaseNameSpaces" attribute](#handling-ignorebasenamespaces-attribute)
-- [soap-stub](#soap-stub)
-  - [Example](#example)
 - [Contributors](#contributors)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
 ## Features
 
-* Very simple API
-* Handles both RPC and Document schema types
-* Supports multiRef SOAP messages (thanks to [@kaven276](https://github.com/kaven276))
-* Support for both synchronous and asynchronous method handlers
-* WS-Security UsernameToken Profile 1.0
-* Supports [Express](http://expressjs.com/) based web server (body parser middleware can be used)
+- Very simple API
+- Handles both RPC and Document schema types
+- Supports multiRef SOAP messages (thanks to [@kaven276](https://github.com/kaven276))
+- Support for both synchronous and asynchronous method handlers
+- WS-Security UsernameToken Profile 1.0
+- Supports [Express](http://expressjs.com/) based web server (body parser middleware can be used)
 
 ## Install
 
@@ -97,52 +95,55 @@ Paid support can be provided as well, please contact one of the active maintaine
 
 ### soap.createClient(url[, options], callback) - create a new SOAP client from a WSDL url. Also supports a local filesystem path.
 
-- `url` (*string*): A HTTP/HTTPS URL, XML or a local filesystem path.
-- `options` (*Object*):
-  - `endpoint` (*string*): Override the host specified by the SOAP service in the WSDL file.
-  - `envelopeKey` (*string*): Set a custom envelope key. (**Default:** `'soap'`)
-  - `preserveWhitespace` (*boolean*): Preserve any leading and trailing whitespace characters in text and cdata.
-  - `escapeXML` (*boolean*): Escape special XML characters (e.g. `&`, `>`, `<` etc) in SOAP messages. (**Default:** `true`)
-  - `suppressStack` (*boolean*): Suppress the full stack trace for error messages.
-  - `returnFault` (*boolean*): Return an `Invalid XML` SOAP fault upon a bad request. (**Default:** `false`)
-  - `forceSoap12Headers` (*boolean*): Enable SOAP 1.2 compliance.
-  - `httpClient` (*Object*): Override the built-in HttpClient object with your own. Must implement `request(rurl, data, callback, exheaders, exoptions)`.
-  - `request` (*Object*): Override the default request module ([Axios](https://axios-http.com/) as of `v0.40.0`).
-  - `wsdl_headers` (*Object*): Set HTTP headers with values to be sent on WSDL requests.
-  - `wsdl_options` (*Object*): Set options for the request module on WSDL requests. If using the default request module, see [Request Config | Axios Docs](https://axios-http.com/docs/req_config).
-  - `disableCache` (*boolean*): Prevents caching WSDL files and option objects.
-  - `wsdlCache` (*IWSDLCache*): Custom cache implementation. If not provided, defaults to caching WSDLs indefinitely.
-  - `overridePromiseSuffix` (*string*): Override the default method name suffix of WSDL operations for Promise-based methods. If any WSDL operation name ends with `Async', you must use this option. (**Default:** `Async`)
-  - `normalizeNames` (*boolean*): Replace non-identifier characters (`[^a-z$_0-9]`) with `_` in WSDL operation names. Note: Clients using WSDLs with two operations like `soap:method` and `soap-method` will be overwritten. In this case, you must use bracket notation instead (`client['soap:method']()`).
-  - `namespaceArrayElements` (*boolean*): Support non-standard array semantics. JSON arrays of the form `{list: [{elem: 1}, {elem: 2}]}` will be marshalled into XML as `<list><elem>1</elem></list> <list><elem>2</elem></list>`. If `false`, it would be marshalled into `<list> <elem>1</elem> <elem>2</elem> </list>`. (**Default:** `true`)
-  - `stream` (*boolean*): Use streams to parse the XML SOAP responses. (**Default:** `false`)
-  - `returnSaxStream` (*boolean*): Return the SAX stream, transferring responsibility of parsing XML to the end user. Only valid when the *stream* option is set to `true`. (**Default:** `false`)
-  - `parseReponseAttachments` (*boolean*): Treat response as multipart/related response with MTOM attachment. Reach attachments on the `lastResponseAttachments` property of SoapClient. (**Default:** `false`)
-  - `encoding` (_string_): response data enconding, used with `parseReponseAttachments`. (**Default:** `utf8`)
-- `callback` (*Function*):
-  - `err` (*Error* | *<AggregateError>*)
-  - `result` (*Any*)
+- `url` (_string_): A HTTP/HTTPS URL, XML or a local filesystem path.
+- `options` (_Object_):
+  - `endpoint` (_string_): Override the host specified by the SOAP service in the WSDL file.
+  - `envelopeKey` (_string_): Set a custom envelope key. (**Default:** `'soap'`)
+  - `preserveWhitespace` (_boolean_): Preserve any leading and trailing whitespace characters in text and cdata.
+  - `escapeXML` (_boolean_): Escape special XML characters (e.g. `&`, `>`, `<` etc) in SOAP messages. (**Default:** `true`)
+  - `suppressStack` (_boolean_): Suppress the full stack trace for error messages.
+  - `returnFault` (_boolean_): Return an `Invalid XML` SOAP fault upon a bad request. (**Default:** `false`)
+  - `forceSoap12Headers` (_boolean_): Enable SOAP 1.2 compliance.
+  - `httpClient` (_Object_): Override the built-in HttpClient object with your own. Must implement `request(rurl, data, callback, exheaders, exoptions)`.
+  - `request` (_Object_): Override the default request module ([Axios](https://axios-http.com/) as of `v0.40.0`).
+  - `wsdl_headers` (_Object_): Set HTTP headers with values to be sent on WSDL requests.
+  - `wsdl_options` (_Object_): Set options for the request module on WSDL requests. If using the default request module, see [Request Config | Axios Docs](https://axios-http.com/docs/req_config).
+  - `disableCache` (_boolean_): Prevents caching WSDL files and option objects.
+  - `wsdlCache` (_IWSDLCache_): Custom cache implementation. If not provided, defaults to caching WSDLs indefinitely.
+  - `overridePromiseSuffix` (_string_): Override the default method name suffix of WSDL operations for Promise-based methods. If any WSDL operation name ends with `Async', you must use this option. (**Default:** `Async`)
+  - `normalizeNames` (_boolean_): Replace non-identifier characters (`[^a-z$_0-9]`) with `_` in WSDL operation names. Note: Clients using WSDLs with two operations like `soap:method` and `soap-method` will be overwritten. In this case, you must use bracket notation instead (`client['soap:method']()`).
+  - `namespaceArrayElements` (_boolean_): Support non-standard array semantics. JSON arrays of the form `{list: [{elem: 1}, {elem: 2}]}` will be marshalled into XML as `<list><elem>1</elem></list> <list><elem>2</elem></list>`. If `false`, it would be marshalled into `<list> <elem>1</elem> <elem>2</elem> </list>`. (**Default:** `true`)
+  - `stream` (_boolean_): Use streams to parse the XML SOAP responses. (**Default:** `false`)
+  - `returnSaxStream` (_boolean_): Return the SAX stream, transferring responsibility of parsing XML to the end user. Only valid when the _stream_ option is set to `true`. (**Default:** `false`)
+  - `parseReponseAttachments` (_boolean_): Treat response as multipart/related response with MTOM attachment. Reach attachments on the `lastResponseAttachments` property of SoapClient. (**Default:** `false`)
+  - `encoding` (_string_): Response data enconding, used with `parseReponseAttachments`. (**Default:** `utf8`)
+  - `forceUseSchemaXmlns` (_boolean_): Force to use schema xmlns when schema prefix not found, this is needed when schema prefix is different for the same namespace in different files, for example wsdl and in imported xsd file fir complex types (**Default** `false`)
+- `callback` (_Function_):
+  - `err` (_Error_ | _\<AggregateError\>_)
+  - `result` (_Any_)
 - Returns: `Client`
 
 #### Example
 
 HTTP/HTTPS:
-``` javascript
-  var soap = require('soap');
-  var url = 'http://example.com/wsdl?wsdl';
-  var args = {name: 'value'};
-
-  soap.createClient(url, {}, function(err, client) {
-      client.MyFunction(args, function(err, result) {
-          console.log(result);
-      });
+
+```javascript
+var soap = require('soap');
+var url = 'http://example.com/wsdl?wsdl';
+var args = { name: 'value' };
+
+soap.createClient(url, {}, function (err, client) {
+  client.MyFunction(args, function (err, result) {
+    console.log(result);
   });
+});
 ```
 
 XML string format:
-``` javascript
-  var soap = require('soap');
-  var xml = `
+
+```javascript
+var soap = require('soap');
+var xml = `
     <?xml version="1.0" encoding="UTF-8"?>
     <definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
        <message name="MyFunctionRequest"/>
@@ -171,169 +172,179 @@ XML string format:
        </service>
     </definitions>
   `;
-  var args = {name: 'value'};
+var args = { name: 'value' };
 
-  soap.createClient(xml, {}, function(err, client) {
-      client.MyFunction(args, function(err, result) {
-          console.log(result);
-      });
+soap.createClient(xml, {}, function (err, client) {
+  client.MyFunction(args, function (err, result) {
+    console.log(result);
   });
+});
 ```
 
-
 Note: for versions of node >0.10.X, you may need to specify `{connection: 'keep-alive'}` in SOAP headers to avoid truncation of longer chunked responses.
 
 ### soap.createClientAsync(url[, options]) - create a new SOAP client from a WSDL url. Also supports a local filesystem path.
 
 Construct a `Promise<Client>` with the given WSDL file.
 
-- `url` (*string*): A HTTP/HTTPS URL, XML or a local filesystem path.
-- `options` (*Object*): See [soap.createClient(url[, options], callback)](#soapcreateclienturl-options-callback---create-a-new-soap-client-from-a-wsdl-url-also-supports-a-local-filesystem-path) for a description.
+- `url` (_string_): A HTTP/HTTPS URL, XML or a local filesystem path.
+- `options` (_Object_): See [soap.createClient(url[, options], callback)](#soapcreateclienturl-options-callback---create-a-new-soap-client-from-a-wsdl-url-also-supports-a-local-filesystem-path) for a description.
 - Returns: `Promise<Client>`
 
 #### Example
 
-``` javascript
-  var soap = require('soap');
-  var url = 'http://example.com/wsdl?wsdl';
-  var args = {name: 'value'};
-
-  // then/catch
-  soap.createClientAsync(url).then((client) => {
+```javascript
+var soap = require('soap');
+var url = 'http://example.com/wsdl?wsdl';
+var args = { name: 'value' };
+
+// then/catch
+soap
+  .createClientAsync(url)
+  .then((client) => {
     return client.MyFunctionAsync(args);
-  }).then((result) => {
+  })
+  .then((result) => {
     console.log(result);
   });
 
-  // async/await
-  var client = await soap.createClientAsync(url);
-  var result = await client.MyFunctionAsync(args);
-  console.log(result[0]);
+// async/await
+var client = await soap.createClientAsync(url);
+var result = await client.MyFunctionAsync(args);
+console.log(result[0]);
 ```
 
 Note: for versions of node >0.10.X, you may need to specify `{connection: 'keep-alive'}` in SOAP headers to avoid truncation of longer chunked responses.
 
-### soap.listen(*server*, *path*, *services*, *wsdl*, *callback*) - create a new SOAP server that listens on *path* and provides *services*.
-### soap.listen(*server*, *options*) - create a new SOAP server that listens on *path* and provides *services*.
-
-- `server` (*Object*): A [http](https://nodejs.org/api/http.html) server or [Express](http://expressjs.com/) framework based server.
-- `path` (*string*)
-- `options` (*Object*): An object containing *server options* and [WSDL Options](#handling-xml-attributes-value-and-xml-wsdloptions)
-  - `path` (*string*)
-  - `services` (*Object*)
-  - `xml` (*string*)
-  - `uri` (*string*)
-  - `pfx` (*string* | *Buffer*): The private key, certificate and CA certs of the server in PFX or PKCS12 format. (Mutually exclusive with the key, cert and ca options.)
-  - `key` (*string* | *Buffer*): The private key of the server in PEM format. (Could be an array of keys). (Required)
-  - `passphrase` (*string*): The passphrase for the private key or pfx.
-  - `cert` (*string* | *Buffer*): The certificate key of the server in PEM format. (Could be an array of certs). (Required)
-  - `ca` (*string[]* | *Buffer[]*): Trusted certificates in PEM format. If this is omitted several well known "root" CAs will be used, like VeriSign. These are used to authorize connections.
-  - `crl` (*string* | *string[]*: PEM encoded CRLs (Certificate Revocation List)
-  - `ciphers` (*string*): A description of the ciphers to use or exclude, separated by `:`. The default cipher suite is:
-  - `enableChunkedEncoding` (*boolean*): Controls chunked transfer encoding in response. Some clients (such as Windows 10's MDM enrollment SOAP client) are sensitive to transfer-encoding mode and can't accept chunked response. This option lets users disable chunked transfer encoding for such clients. (**Default:** `true`)
-- `services` (*Object*)
-- `wsdl` (*string*): An XML string that defines the service.
-- `callback` (*Function*): A function to run after the server has been initialized.
+### soap.listen(_server_, _path_, _services_, _wsdl_, _callback_) - create a new SOAP server that listens on _path_ and provides _services_.
+
+### soap.listen(_server_, _options_) - create a new SOAP server that listens on _path_ and provides _services_.
+
+- `server` (_Object_): A [http](https://nodejs.org/api/http.html) server or [Express](http://expressjs.com/) framework based server.
+- `path` (_string_)
+- `options` (_Object_): An object containing _server options_ and [WSDL Options](#handling-xml-attributes-value-and-xml-wsdloptions)
+  - `path` (_string_)
+  - `services` (_Object_)
+  - `xml` (_string_)
+  - `uri` (_string_)
+  - `pfx` (_string_ | _Buffer_): The private key, certificate and CA certs of the server in PFX or PKCS12 format. (Mutually exclusive with the key, cert and ca options.)
+  - `key` (_string_ | _Buffer_): The private key of the server in PEM format. (Could be an array of keys). (Required)
+  - `passphrase` (_string_): The passphrase for the private key or pfx.
+  - `cert` (_string_ | _Buffer_): The certificate key of the server in PEM format. (Could be an array of certs). (Required)
+  - `ca` (_string[]_ | _Buffer[]_): Trusted certificates in PEM format. If this is omitted several well known "root" CAs will be used, like VeriSign. These are used to authorize connections.
+  - `crl` (_string_ | _string[]_: PEM encoded CRLs (Certificate Revocation List)
+  - `ciphers` (_string_): A description of the ciphers to use or exclude, separated by `:`. The default cipher suite is:
+  - `enableChunkedEncoding` (_boolean_): Controls chunked transfer encoding in response. Some clients (such as Windows 10's MDM enrollment SOAP client) are sensitive to transfer-encoding mode and can't accept chunked response. This option lets users disable chunked transfer encoding for such clients. (**Default:** `true`)
+- `services` (_Object_)
+- `wsdl` (_string_): An XML string that defines the service.
+- `callback` (_Function_): A function to run after the server has been initialized.
 - Returns: `Server`
 
 #### Example
 
-``` javascript
-  var myService = {
-      MyService: {
-          MyPort: {
-              MyFunction: function(args) {
-                  return {
-                      name: args.name
-                  };
-              },
-
-              // This is how to define an asynchronous function with a callback.
-              MyAsyncFunction: function(args, callback) {
-                  // do some work
-                  callback({
-                      name: args.name
-                  });
-              },
-
-              // This is how to define an asynchronous function with a Promise.
-              MyPromiseFunction: function(args) {
-                  return new Promise((resolve) => {
-                    // do some work
-                    resolve({
-                      name: args.name
-                    });
-                  });
-              },
-
-              // This is how to receive incoming headers
-              HeadersAwareFunction: function(args, cb, headers) {
-                  return {
-                      name: headers.Token
-                  };
-              },
-
-              // You can also inspect the original `req`
-              reallyDetailedFunction: function(args, cb, headers, req) {
-                  console.log('SOAP `reallyDetailedFunction` request from ' + req.connection.remoteAddress);
-                  return {
-                      name: headers.Token
-                  };
-              }
-          }
-      }
-  };
+```javascript
+var myService = {
+  MyService: {
+    MyPort: {
+      MyFunction: function (args) {
+        return {
+          name: args.name,
+        };
+      },
 
-  var xml = require('fs').readFileSync('myservice.wsdl', 'utf8');
+      // This is how to define an asynchronous function with a callback.
+      MyAsyncFunction: function (args, callback) {
+        // do some work
+        callback({
+          name: args.name,
+        });
+      },
 
-  //http server example
-  var server = http.createServer(function(request,response) {
-      response.end('404: Not Found: ' + request.url);
-  });
+      // This is how to define an asynchronous function with a Promise.
+      MyPromiseFunction: function (args) {
+        return new Promise((resolve) => {
+          // do some work
+          resolve({
+            name: args.name,
+          });
+        });
+      },
 
-  server.listen(8000);
-  soap.listen(server, '/wsdl', myService, xml, function(){
-    console.log('server initialized');
-  });
+      // This is how to receive incoming headers
+      HeadersAwareFunction: function (args, cb, headers) {
+        return {
+          name: headers.Token,
+        };
+      },
 
-  //express server example
-  var app = express();
-  //body parser middleware are supported (optional)
-  app.use(bodyParser.raw({type: function(){return true;}, limit: '5mb'}));
-  app.listen(8001, function(){
-      //Note: /wsdl route will be handled by soap module
-      //and all other routes & middleware will continue to work
-      soap.listen(app, '/wsdl', myService, xml, function(){
-        console.log('server initialized');
-      });
-  });
+      // You can also inspect the original `req`
+      reallyDetailedFunction: function (args, cb, headers, req) {
+        console.log('SOAP `reallyDetailedFunction` request from ' + req.connection.remoteAddress);
+        return {
+          name: headers.Token,
+        };
+      },
+    },
+  },
+};
+
+var xml = require('fs').readFileSync('myservice.wsdl', 'utf8');
+
+//http server example
+var server = http.createServer(function (request, response) {
+  response.end('404: Not Found: ' + request.url);
+});
 
+server.listen(8000);
+soap.listen(server, '/wsdl', myService, xml, function () {
+  console.log('server initialized');
+});
+
+//express server example
+var app = express();
+//body parser middleware are supported (optional)
+app.use(
+  bodyParser.raw({
+    type: function () {
+      return true;
+    },
+    limit: '5mb',
+  }),
+);
+app.listen(8001, function () {
+  //Note: /wsdl route will be handled by soap module
+  //and all other routes & middleware will continue to work
+  soap.listen(app, '/wsdl', myService, xml, function () {
+    console.log('server initialized');
+  });
+});
 ```
 
-``` javascript
+```javascript
 var xml = require('fs').readFileSync('myservice.wsdl', 'utf8');
 
 soap.listen(server, {
-    // Server options.
-    path: '/wsdl',
-    services: myService,
-    xml: xml,
-
-    // WSDL options.
-    attributesKey: 'theAttrs',
-    valueKey: 'theVal',
-    xmlKey: 'theXml'
+  // Server options.
+  path: '/wsdl',
+  services: myService,
+  xml: xml,
+
+  // WSDL options.
+  attributesKey: 'theAttrs',
+  valueKey: 'theVal',
+  xmlKey: 'theXml',
 });
 ```
 
 ### Server Logging
 
 If the `log` method is defined, it will be called with:
+
 - `type`: 'received', 'replied', 'info' or 'error'.
 - `data`: The data to be logged which will be an XML for 'received' and 'replied' or a message for the other types.
 - `req`: The original request object
 
-``` javascript
+```javascript
   server = soap.listen(...)
   server.log = function(type, data, req) {
     // type is 'received', 'replied', 'info' or 'error'
@@ -344,11 +355,11 @@ If the `log` method is defined, it will be called with:
 
 Server instances emit the following events:
 
-* request - Emitted for every received messages.
+- request - Emitted for every received messages.
   The signature of the callback is `function(request, methodName)`.
-* response - Emitted before sending SOAP response.
+- response - Emitted before sending SOAP response.
   The signature of the callback is `function(response, methodName)`.
-* headers - Emitted when the SOAP Headers are not empty.
+- headers - Emitted when the SOAP Headers are not empty.
   The signature of the callback is `function(headers, methodName)`.
 
 The sequence order of the calls is `request`, `headers` and then the dedicated
@@ -369,31 +380,31 @@ Pass in `oneWay` object in server options. Use the following keys:
 A service method can reply with a SOAP Fault to a client by `throw`ing an
 object with a `Fault` property.
 
-``` javascript
-  throw {
-    Fault: {
-      Code: {
-        Value: 'soap:Sender',
-        Subcode: { value: 'rpc:BadArguments' }
-      },
-      Reason: { Text: 'Processing Error' }
-    }
-  };
+```javascript
+throw {
+  Fault: {
+    Code: {
+      Value: 'soap:Sender',
+      Subcode: { value: 'rpc:BadArguments' },
+    },
+    Reason: { Text: 'Processing Error' },
+  },
+};
 ```
 
-To change the HTTP statusCode of the response include it on the fault.  The statusCode property will not be put on the xml message.
+To change the HTTP statusCode of the response include it on the fault. The statusCode property will not be put on the xml message.
 
-``` javascript
-  throw {
-    Fault: {
-      Code: {
-        Value: 'soap:Sender',
-        Subcode: { value: 'rpc:BadArguments' }
-      },
-      Reason: { Text: 'Processing Error' },
-      statusCode: 500
-    }
-  };
+```javascript
+throw {
+  Fault: {
+    Code: {
+      Value: 'soap:Sender',
+      Subcode: { value: 'rpc:BadArguments' },
+    },
+    Reason: { Text: 'Processing Error' },
+    statusCode: 500,
+  },
+};
 ```
 
 ### Server security example using PasswordDigest
@@ -401,7 +412,8 @@ To change the HTTP statusCode of the response include it on the fault.  The stat
 If `server.authenticate` is not defined then no authentication will take place.
 
 Asynchronous authentication:
-``` javascript
+
+```javascript
   server = soap.listen(...)
   server.authenticate = function(security, callback) {
     var created, nonce, password, user, token;
@@ -420,7 +432,8 @@ Asynchronous authentication:
 ```
 
 Synchronous authentication:
-``` javascript
+
+```javascript
   server = soap.listen(...)
   server.authenticate = function(security) {
     var created, nonce, password, user, token;
@@ -436,21 +449,20 @@ The `server.authorizeConnection` method is called prior to the soap service meth
 If the method is defined and returns `false` then the incoming connection is
 terminated.
 
-``` javascript
+```javascript
   server = soap.listen(...)
   server.authorizeConnection = function(req) {
     return true; // or false
   };
 ```
 
-
 ## SOAP Headers
 
 ### Received SOAP Headers
 
 A service method can look at the SOAP headers by providing a 3rd arguments.
 
-``` javascript
+```javascript
   {
       HeadersAwareFunction: function(args, cb, headers) {
           return {
@@ -464,7 +476,7 @@ It is also possible to subscribe to the 'headers' event.
 The event is triggered before the service method is called, and only when the
 SOAP Headers are not empty.
 
-``` javascript
+```javascript
   server = soap.listen(...)
   server.on('headers', function(headers, methodName) {
     // It is possible to change the value of the headers
@@ -482,20 +494,21 @@ second parameter is the name of the SOAP method that will called
 Both client & server can define SOAP headers that will be added to what they send.
 They provide the following methods to manage the headers.
 
+#### _addSoapHeader_(soapHeader[, name, namespace, xmlns]) - add soapHeader to soap:Header node
 
-#### *addSoapHeader*(soapHeader[, name, namespace, xmlns]) - add soapHeader to soap:Header node
 ##### Parameters
- - `soapHeader`     Object({rootName: {name: 'value'}}), strict xml-string,
-                    or function (server only)
+
+- `soapHeader` Object({rootName: {name: 'value'}}), strict xml-string,
+  or function (server only)
 
 For servers only, `soapHeader` can be a function, which allows headers to be
 dynamically generated from information in the request. This function will be
 called with the following arguments for each received request:
 
- - `methodName`     The name of the request method
- - `args`           The arguments of the request
- - `headers`        The headers in the request
- - `req`            The original request object
+- `methodName` The name of the request method
+- `args` The arguments of the request
+- `headers` The headers in the request
+- `req` The original request object
 
 The return value of the function must be an Object({rootName: {name: 'value'}})
 or strict xml-string, which will be inserted as an outgoing header of the
@@ -503,7 +516,7 @@ response to that request.
 
 For example:
 
-``` javascript
+```javascript
   server = soap.listen(...);
   server.addSoapHeader(function(methodName, args, headers, req) {
     console.log('Adding headers for method', methodName);
@@ -516,58 +529,62 @@ For example:
 ```
 
 ##### Returns
+
 The index where the header is inserted.
 
 ##### Optional parameters when first arg is object :
- - `name`           Unknown parameter (it could just a empty string)
- - `namespace`      prefix of xml namespace
- - `xmlns`          URI
 
-#### *changeSoapHeader*(index, soapHeader[, name, namespace, xmlns]) - change an already existing soapHeader
+- `name` Unknown parameter (it could just a empty string)
+- `namespace` prefix of xml namespace
+- `xmlns` URI
+
+#### _changeSoapHeader_(index, soapHeader[, name, namespace, xmlns]) - change an already existing soapHeader
+
 ##### Parameters
- - `index`          index of the header to replace with provided new value
- - `soapHeader`     Object({rootName: {name: 'value'}}), strict xml-string
-                    or function (server only)
 
-See `addSoapHeader` for how to pass a function into `soapHeader`.
+- `index` index of the header to replace with provided new value
+- `soapHeader` Object({rootName: {name: 'value'}}), strict xml-string
+  or function (server only)
 
-#### *getSoapHeaders*() - return all defined headers
+See `addSoapHeader` for how to pass a function into `soapHeader`.
 
-#### *clearSoapHeaders*() - remove all defined headers
+#### _getSoapHeaders_() - return all defined headers
 
+#### _clearSoapHeaders_() - remove all defined headers
 
 ## Client
 
-An instance of `Client` is passed to the `soap.createClient` callback.  It is used to execute methods on the soap service.
+An instance of `Client` is passed to the `soap.createClient` callback. It is used to execute methods on the soap service.
 
 ### Client.describe() - description of services, ports and methods as a JavaScript object
 
-``` javascript
-  client.describe() // returns
-    {
-      MyService: {
-        MyPort: {
-          MyFunction: {
-            input: {
-              name: 'string'
-            }
-          }
+```javascript
+client.describe(); // returns
+{
+  MyService: {
+    MyPort: {
+      MyFunction: {
+        input: {
+          name: 'string';
         }
       }
     }
+  }
+}
 ```
 
 ### Client.setSecurity(security) - use the specified security protocol
 
 See [Security](#security) for example usage.
 
-### Client.*method*(args, callback, options) - call *method* on the SOAP service.
+### Client._method_(args, callback, options) - call _method_ on the SOAP service.
+
+- `args` (_Object_): Arguments that generate an XML document inside of the SOAP Body section.
+- `callback` (_Function_)
+- `options` (_Object_): Set options for the request module on WSDL requests. If using the default request module, see [Request Config | Axios Docs](https://axios-http.com/docs/req_config). Additional options supported by `node-soap` are documented below:
+  - `forever` (_boolean_): Enables keep-alive connections and pools them
+  - `attachments` (_Array_): array of attachment objects. This converts the request into MTOM: _headers['Content-Type']='multipart/related; type="application/xop+xml"; start= ... '_
 
-- `args` (*Object*): Arguments that generate an XML document inside of the SOAP Body section.
-- `callback` (*Function*)
-- `options` (*Object*): Set options for the request module on WSDL requests. If using the default request module, see [Request Config | Axios Docs](https://axios-http.com/docs/req_config). Additional options supported by `node-soap` are documented below:
-  - `forever` (*boolean*): Enables keep-alive connections and pools them
-  - `attachments` (*Array*): array of attachment objects. This converts the request into MTOM: _headers['Content-Type']='multipart/related; type="application/xop+xml"; start= ... '_
   ```
   [{
         mimetype: content mimetype,
@@ -578,41 +595,43 @@ See [Security](#security) for example usage.
     ...
   ]
   ```
-  - `forceMTOM` (*boolean*): Send the request as MTOM even if you don't have attachments.
-  - `forceGzip` (*boolean*): Force transfer-encoding in gzip. (**Default:** `false`)
+
+  - `forceMTOM` (_boolean_): Send the request as MTOM even if you don't have attachments.
+  - `forceGzip` (_boolean_): Force transfer-encoding in gzip. (**Default:** `false`)
 
 #### Example
 
-``` javascript
-  client.MyFunction({name: 'value'}, function(err, result, rawResponse, soapHeader, rawRequest) {
-      // result is a javascript object
-      // rawResponse is the raw xml response string
-      // soapHeader is the response soap header as a javascript object
-      // rawRequest is the raw xml request string
-  })
+```javascript
+client.MyFunction({ name: 'value' }, function (err, result, rawResponse, soapHeader, rawRequest) {
+  // result is a javascript object
+  // rawResponse is the raw xml response string
+  // soapHeader is the response soap header as a javascript object
+  // rawRequest is the raw xml request string
+});
 ```
 
-### Client.*method*Async(args, options) - call *method* on the SOAP service.
+### Client.*method*Async(args, options) - call _method_ on the SOAP service.
 
-- `args` (*Object*): Arguments that generate an XML document inside of the SOAP Body section.
-- `options` (*Object*): See [Client.*method*(args, callback, options) - call *method* on the SOAP service.](#clientmethodargs-callback-options---call-method-on-the-soap-service) for a description.
+- `args` (_Object_): Arguments that generate an XML document inside of the SOAP Body section.
+- `options` (_Object_): See [Client._method_(args, callback, options) - call _method_ on the SOAP service.](#clientmethodargs-callback-options---call-method-on-the-soap-service) for a description.
 
 #### Example
 
-``` javascript
-  client.MyFunctionAsync({name: 'value'}).then((result) => {
-    // result is a javascript array containing result, rawResponse, soapheader, and rawRequest
-    // result is a javascript object
-    // rawResponse is the raw xml response string
-    // soapHeader is the response soap header as a javascript object
-    // rawRequest is the raw xml request string
-  })
+```javascript
+client.MyFunctionAsync({ name: 'value' }).then((result) => {
+  // result is a javascript array containing result, rawResponse, soapheader, and rawRequest
+  // result is a javascript object
+  // rawResponse is the raw xml response string
+  // soapHeader is the response soap header as a javascript object
+  // rawRequest is the raw xml request string
+});
 ```
 
 ##### Example with JSON for the `args`
+
 The example above uses `{name: 'value'}` as the args. This may generate a SOAP messages such as:
 
-``` javascript
+```javascript
 <?xml version="1.0" encoding="utf-8"?>
 <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <soapenv:Body>
@@ -623,12 +642,13 @@ The example above uses `{name: 'value'}` as the args. This may generate a SOAP m
 </soapenv:Envelope>
 ```
 
-Note that the "Request" element in the output above comes from the WSDL.  If an element in `args` contains no namespace prefix, the default namespace is assumed.  Otherwise, you must add the namespace prefixes to the element names as necessary (e.g., `ns1:name`).
+Note that the "Request" element in the output above comes from the WSDL. If an element in `args` contains no namespace prefix, the default namespace is assumed. Otherwise, you must add the namespace prefixes to the element names as necessary (e.g., `ns1:name`).
 
 Currently, when supplying JSON args, elements may not contain both child elements and a text value, even though that is allowed in the XML specification.
 
 ##### Example with XML String for the `args`
-You may pass in a fully-formed XML string instead the individual elements in JSON `args` and attributes that make up the XML.  The XML string should not contain an XML declaration (e.g., `<?xml version="1.0" encoding="UTF-8"?>`) or a document type declaration (e.g., `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">`).
+
+You may pass in a fully-formed XML string instead the individual elements in JSON `args` and attributes that make up the XML. The XML string should not contain an XML declaration (e.g., `<?xml version="1.0" encoding="UTF-8"?>`) or a document type declaration (e.g., `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">`).
 
 ```
  var args = { _xml: "<ns1:MyRootElement xmlns:ns1="http://www.example.com/v1/ns1">
@@ -636,96 +656,95 @@ You may pass in a fully-formed XML string instead the individual elements in JSO
                      </ns1:MyRootElement>"
             };
 ```
-You must specify all of the namespaces and namespace prefixes yourself.  The element(s) from the WSDL are not utilized as they were in  the "Example with JSON as the `args`" example above, which automatically populated the "Request" element.
 
-### Client.*service*.*port*.*method*(args, callback[, options[, extraHeaders]]) - call a *method* using a specific *service* and *port*
+You must specify all of the namespaces and namespace prefixes yourself. The element(s) from the WSDL are not utilized as they were in the "Example with JSON as the `args`" example above, which automatically populated the "Request" element.
+
+### Client._service_._port_._method_(args, callback[, options[, extraHeaders]]) - call a _method_ using a specific _service_ and _port_
 
-- `args` (*Object*): Arguments that generate an XML document inside of the SOAP Body section.
-- `callback` (*Function*)
-- `options` (*Object*): See [Client.*method*(args, callback, options) - call *method* on the SOAP service.](#clientmethodargs-callback-options---call-method-on-the-soap-service) for a description.
-- `extraHeaders` (*Object*): Sets HTTP headers for the WSDL request.
+- `args` (_Object_): Arguments that generate an XML document inside of the SOAP Body section.
+- `callback` (_Function_)
+- `options` (_Object_): See [Client._method_(args, callback, options) - call _method_ on the SOAP service.](#clientmethodargs-callback-options---call-method-on-the-soap-service) for a description.
+- `extraHeaders` (_Object_): Sets HTTP headers for the WSDL request.
 
 #### Example
 
-``` javascript
-  client.MyService.MyPort.MyFunction({name: 'value'}, function(err, result) {
-      // result is a javascript object
-  })
+```javascript
+client.MyService.MyPort.MyFunction({ name: 'value' }, function (err, result) {
+  // result is a javascript object
+});
 ```
 
 #### Options (optional)
- - Accepts any option that the request module accepts, see [here.](https://github.com/mikeal/request)
- - For example, you could set a timeout of 5 seconds on the request like this:
-``` javascript
-  client.MyService.MyPort.MyFunction({name: 'value'}, function(err, result) {
-      // result is a javascript object
-  }, {timeout: 5000})
+
+- Accepts any option that the request module accepts, see [here.](https://github.com/mikeal/request)
+- For example, you could set a timeout of 5 seconds on the request like this:
+
+```javascript
+client.MyService.MyPort.MyFunction(
+  { name: 'value' },
+  function (err, result) {
+    // result is a javascript object
+  },
+  { timeout: 5000 },
+);
 ```
 
 - You can measure the elapsed time on the request by passing the time option:
-``` javascript
-  client.MyService.MyPort.MyFunction({name: 'value'}, function(err, result) {
-      // client.lastElapsedTime - the elapsed time of the last request in milliseconds
-  }, {time: true})
+
+```javascript
+client.MyService.MyPort.MyFunction(
+  { name: 'value' },
+  function (err, result) {
+    // client.lastElapsedTime - the elapsed time of the last request in milliseconds
+  },
+  { time: true },
+);
 ```
 
 - Also, you could pass your soap request through a debugging proxy such as [Fiddler](http://www.telerik.com/fiddler) or [Betwixt](https://github.com/kdzwinel/betwixt).
-``` javascript
-  client.MyService.MyPort.MyFunction({name: 'value'}, function(err, result) {
-      // client.lastElapsedTime - the elapsed time of the last request in milliseconds
-  }, {
-      proxy: {
-          protocol: 'https',
-          host: '127.0.0.1',
-          port: 9000,
-          auth: {
-              username: 'mikeymike',
-              password: 'rapunz3l'
-          }
-      }
-  })
+
+```javascript
+client.MyService.MyPort.MyFunction(
+  { name: 'value' },
+  function (err, result) {
+    // client.lastElapsedTime - the elapsed time of the last request in milliseconds
+  },
+  {
+    proxy: {
+      protocol: 'https',
+      host: '127.0.0.1',
+      port: 9000,
+      auth: {
+        username: 'mikeymike',
+        password: 'rapunz3l',
+      },
+    },
+  },
+);
 ```
 
 - You can modify xml (string) before call:
- ``` javascript
-   client.MyService.MyPort.MyFunction({name: 'value'}, function(err, result) {
-       // client.lastElapsedTime - the elapsed time of the last request in milliseconds
-   }, {postProcess: function(_xml) {
-     return _xml.replace('text', 'newtext');
-   }})
- ```
-
-- Making `postProcess` either synchronous or asynchronous with a `Promise`:
-  - Synchronous (classic):
-    ```javascript
-      // ...
-      client.registerUser(requestBody, {
-        postProcess: (xml) => {
-          const testString = "Jane"
-          xml = xml.replace("John", testString)
-          return xml;
-        }
-      }
-      // ...
-    ```
-  - Asynchronous (resolves promise on async invoke of `postProcess`):
-    ```javascript
-      // ...
-      client.registerUser(requestBody, {
-        postProcess: async (xml) => {
-          const testString = await new Promise(resolve => setTimeout(() => resolve("Jane"), 50));
-          xml = xml.replace("John", testString)
-          return xml;
-        }
-      }
-      // ...
-    ```
+
+```javascript
+client.MyService.MyPort.MyFunction(
+  { name: 'value' },
+  function (err, result) {
+    // client.lastElapsedTime - the elapsed time of the last request in milliseconds
+  },
+  {
+    postProcess: function (_xml) {
+      return _xml.replace('text', 'newtext');
+    },
+  },
+);
+```
 
 #### Extra Headers (optional)
 
 Object properties define extra HTTP headers to be sent on the request.
 
 - Add custom User-Agent:
+
 ```javascript
 client.addHttpHeader('User-Agent', `CustomUserAgent`);
 ```
@@ -735,57 +754,72 @@ client.addHttpHeader('User-Agent', `CustomUserAgent`);
 To align method call signature with node' standard callback-last patter and event allow promisification of method calls, the following method signatures are also supported:
 
 ```javascript
-client.MyService.MyPort.MyFunction({name: 'value'}, options, function (err, result) {
+client.MyService.MyPort.MyFunction({ name: 'value' }, options, function (err, result) {
   // result is a javascript object
-})
+});
 
-client.MyService.MyPort.MyFunction({name: 'value'}, options, extraHeaders, function (err, result) {
+client.MyService.MyPort.MyFunction({ name: 'value' }, options, extraHeaders, function (err, result) {
   // result is a javascript object
-})
+});
 ```
 
 ### Overriding the namespace prefix
-`node-soap` is still working out some kinks regarding namespaces.  If you find that an element is given the wrong namespace prefix in the request body, you can add the prefix to it's name in the containing object.  I.E.:
+
+`node-soap` is still working out some kinks regarding namespaces. If you find that an element is given the wrong namespace prefix in the request body, you can add the prefix to it's name in the containing object. I.E.:
 
 ```javascript
-  client.MyService.MyPort.MyFunction({'ns1:name': 'value'}, function(err, result) {
-      // request body sent with `<ns1:name`, regardless of what the namespace should have been.
-  }, {timeout: 5000})
+client.MyService.MyPort.MyFunction(
+  { 'ns1:name': 'value' },
+  function (err, result) {
+    // request body sent with `<ns1:name`, regardless of what the namespace should have been.
+  },
+  { timeout: 5000 },
+);
 ```
 
 - Remove namespace prefix of param
 
 ```javascript
-  client.MyService.MyPort.MyFunction({':name': 'value'}, function(err, result) {
-      // request body sent with `<name`, regardless of what the namespace should have been.
-  }, {timeout: 5000})
+client.MyService.MyPort.MyFunction(
+  { ':name': 'value' },
+  function (err, result) {
+    // request body sent with `<name`, regardless of what the namespace should have been.
+  },
+  { timeout: 5000 },
+);
 ```
 
-### Client.*lastRequest* - the property that contains last full soap request for client logging
+### Client._lastRequest_ - the property that contains last full soap request for client logging
 
 ### Client.setEndpoint(url) - overwrite the SOAP service endpoint address
 
 ### Client Events
+
 Client instances emit the following events:
 
 ### _request_
+
 Emitted before a request is sent. The event handler has the signature `(xml, eid)`.
 
 - _xml_ - The entire Soap request (Envelope) including headers.
 - _eid_ - The exchange id.
 
 ### _message_
+
 Emitted before a request is sent, but only the body is passed to the event handler. Useful if you don't want to log /store Soap headers. The event handler has the signature `(message, eid)`.
 
 - _message_ - Soap body contents.
 - _eid_ - The exchange id.
 
 ### _soapError_
+
 Emitted when an erroneous response is received. Useful if you want to globally log errors. The event handler has the signature `(error, eid)`.
 
 - _error_ - An error object which also contains the resoponse.
 - _eid_ - The exchange id.
+
 ### _response_
+
 Emitted after a response is received. This is emitted for all responses (both success and errors). The event handler has the signature `(body, response, eid)`
 
 - _body_ - The SOAP response body.
@@ -802,9 +836,7 @@ By default exchange ids are generated by using node-uuid but you can use options
 Example :
 
 ```javascript
-  client.MyService.MyPort.MyFunction(args , function(err, result) {
-
-  }, {exchangeId: myExchangeId})
+client.MyService.MyPort.MyFunction(args, function (err, result) {}, { exchangeId: myExchangeId });
 ```
 
 ## WSDL
@@ -817,18 +849,20 @@ services).
 ## WSDL.constructor(wsdl, baseURL, options):
 
 Construct a WSDL instance from either the WSDL content or the URL to the WSDL.
+
 #### Parameters
 
-  - wsdl: A string wSDL or an URL to the WSDL
-  - baseURL: base URL for the SOAP API
-  - options: options (see source for details), use `{}` as default.
+- wsdl: A string wSDL or an URL to the WSDL
+- baseURL: base URL for the SOAP API
+- options: options (see source for details), use `{}` as default.
 
 ### wsdl.xmlToObject(xml):
 
 Unmarshal XML to object.
 
 #### Parameters:
-  - xml: SOAP response (XML) to unmarshal
+
+- xml: SOAP response (XML) to unmarshal
 
 #### Returns:
 
@@ -839,16 +873,18 @@ Object containing the object types from the xml as keys.
 Marshal an object to XML
 
 #### Parameters:
-  - object: Object to marshal
-  - typeName: type (as per the wsdl) of the object
-  - namespacePrefix: namespace prefix
-  - namespaceURI: URI of the namespace
+
+- object: Object to marshal
+- typeName: type (as per the wsdl) of the object
+- namespacePrefix: namespace prefix
+- namespaceURI: URI of the namespace
 
 #### Returns:
 
 XML representation of object.
 
 #### Example:
+
 ```typescript
 // Abstracted from a real use case
 import { AxiosInstance } from 'axios';
@@ -888,154 +924,161 @@ async function samplePostCall(prospect: IProspectType) {
 }
 ```
 
-
 ## Security
 
-`node-soap` has several default security protocols.  You can easily add your own
-as well.  The interface is quite simple. Each protocol defines these optional methods:
-* `addOptions(options)` - a method that accepts an options arg that is eventually passed directly to `request`.
-* `addHeaders(headers)` - a method that accepts an argument with HTTP headers, to add new ones.
-* `toXML()` - a method that returns a string of XML to be appended to the SOAP headers. Not executed if `postProcess` is also defined.
-* `postProcess(xml, envelopeKey)` - a method that receives the the assembled request XML plus envelope key, and returns a processed string of XML. Executed before `options.postProcess`.
+`node-soap` has several default security protocols. You can easily add your own
+as well. The interface is quite simple. Each protocol defines these optional methods:
+
+- `addOptions(options)` - a method that accepts an options arg that is eventually passed directly to `request`.
+- `addHeaders(headers)` - a method that accepts an argument with HTTP headers, to add new ones.
+- `toXML()` - a method that returns a string of XML to be appended to the SOAP headers. Not executed if `postProcess` is also defined.
+- `postProcess(xml, envelopeKey)` - a method that receives the the assembled request XML plus envelope key, and returns a processed string of XML. Executed before `options.postProcess`.
 
 ### BasicAuthSecurity
 
-``` javascript
-  client.setSecurity(new soap.BasicAuthSecurity('username', 'password'));
+```javascript
+client.setSecurity(new soap.BasicAuthSecurity('username', 'password'));
 ```
 
 ### BearerSecurity
 
-``` javascript
-  client.setSecurity(new soap.BearerSecurity('token'));
+```javascript
+client.setSecurity(new soap.BearerSecurity('token'));
 ```
 
 ### ClientSSLSecurity
 
 _Note_: If you run into issues using this protocol, consider passing these options
 as default request options to the constructor:
-* `rejectUnauthorized: false`
-* `strictSSL: false`
-* `secureOptions: constants.SSL_OP_NO_TLSv1_2` (this is likely needed for node >= 10.0)
+
+- `rejectUnauthorized: false`
+- `strictSSL: false`
+- `secureOptions: constants.SSL_OP_NO_TLSv1_2` (this is likely needed for node >= 10.0)
 
 If you want to reuse tls sessions, you can use the option `forever: true`.
 
-``` javascript
-client.setSecurity(new soap.ClientSSLSecurity(
-                '/path/to/key',
-                'path/to/cert',
-                '/path/to/ca-cert',  /*or an array of buffer: [fs.readFileSync('/path/to/ca-cert/1', 'utf8'),
-                'fs.readFileSync('/path/to/ca-cert/2', 'utf8')], */
-                {   /*default request options like */
-                    // strictSSL: true,
-                    // rejectUnauthorized: false,
-                    // hostname: 'some-hostname'
-                    // secureOptions: constants.SSL_OP_NO_TLSv1_2,
-                    // forever: true,
-                },
-      ));
+```javascript
+client.setSecurity(
+  new soap.ClientSSLSecurity(
+    '/path/to/key',
+    'path/to/cert',
+    '/path/to/ca-cert' /*or an array of buffer: [fs.readFileSync('/path/to/ca-cert/1', 'utf8'),
+                'fs.readFileSync('/path/to/ca-cert/2', 'utf8')], */,
+    {
+      /*default request options like */
+      // strictSSL: true,
+      // rejectUnauthorized: false,
+      // hostname: 'some-hostname'
+      // secureOptions: constants.SSL_OP_NO_TLSv1_2,
+      // forever: true,
+    },
+  ),
+);
 ```
 
 ### ClientSSLSecurityPFX
 
 _Note_: If you run into issues using this protocol, consider passing these options
 as default request options to the constructor:
-* `rejectUnauthorized: false`
-* `strictSSL: false`
-* `secureOptions: constants.SSL_OP_NO_TLSv1_2` (this is likely needed for node >= 10.0)
+
+- `rejectUnauthorized: false`
+- `strictSSL: false`
+- `secureOptions: constants.SSL_OP_NO_TLSv1_2` (this is likely needed for node >= 10.0)
 
 If you want to reuse tls sessions, you can use the option `forever: true`.
 
-``` javascript
-client.setSecurity(new soap.ClientSSLSecurityPFX(
-                '/path/to/pfx/cert', // or a buffer: [fs.readFileSync('/path/to/pfx/cert', 'utf8'),
-                'path/to/optional/passphrase',
-                {   /*default request options like */
-                    // strictSSL: true,
-                    // rejectUnauthorized: false,
-                    // hostname: 'some-hostname'
-                    // secureOptions: constants.SSL_OP_NO_TLSv1_2,
-                    // forever: true,
-                },
-      ));
+```javascript
+client.setSecurity(
+  new soap.ClientSSLSecurityPFX(
+    '/path/to/pfx/cert', // or a buffer: [fs.readFileSync('/path/to/pfx/cert', 'utf8'),
+    'path/to/optional/passphrase',
+    {
+      /*default request options like */
+      // strictSSL: true,
+      // rejectUnauthorized: false,
+      // hostname: 'some-hostname'
+      // secureOptions: constants.SSL_OP_NO_TLSv1_2,
+      // forever: true,
+    },
+  ),
+);
 ```
 
 ### WSSecurity
 
 `WSSecurity` implements WS-Security. UsernameToken and PasswordText/PasswordDigest is supported.
 
-``` javascript
-  var options = {
-    hasNonce: true,
-    actor: 'actor'
-  };
-  var wsSecurity = new soap.WSSecurity('username', 'password', options)
-  client.setSecurity(wsSecurity);
+```javascript
+var options = {
+  hasNonce: true,
+  actor: 'actor',
+};
+var wsSecurity = new soap.WSSecurity('username', 'password', options);
+client.setSecurity(wsSecurity);
 ```
+
 the `options` object is optional and can contain the following properties:
-* `passwordType`: 'PasswordDigest' or 'PasswordText' (default: `'PasswordText'`)
-* `hasTimeStamp`: adds Timestamp element (default: `true`)
-* `hasTokenCreated`: adds Created element (default: `true`)
-* `hasNonce`: adds Nonce element (default: `false`)
-* `mustUnderstand`: adds mustUnderstand=1 attribute to security tag (default: `false`)
-* `actor`: if set, adds Actor attribute with given value to security tag (default: `''`)
+
+- `passwordType`: 'PasswordDigest' or 'PasswordText' (default: `'PasswordText'`)
+- `hasTimeStamp`: adds Timestamp element (default: `true`)
+- `hasTokenCreated`: adds Created element (default: `true`)
+- `hasNonce`: adds Nonce element (default: `false`)
+- `mustUnderstand`: adds mustUnderstand=1 attribute to security tag (default: `false`)
+- `actor`: if set, adds Actor attribute with given value to security tag (default: `''`)
 
 ### WSSecurityCert
 
 WS-Security X509 Certificate support.
 
-``` javascript
-  var privateKey = fs.readFileSync(privateKeyPath);
-  var publicKey = fs.readFileSync(publicKeyPath);
-  var password = ''; // optional password
-  var options = {
-    hasTimeStamp: true,
-    additionalReferences: [
-        'wsa:Action',
-        'wsa:ReplyTo',
-        'wsa:To',
-    ],
-    signerOptions: {
-        prefix: 'ds',
-        attrs: { Id: 'Signature' },
-        existingPrefixes: {
-            wsse: 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd',
-        }
-     }
-  }
-  var wsSecurity = new soap.WSSecurityCert(privateKey, publicKey, password, options);
-  client.setSecurity(wsSecurity);
+```javascript
+var privateKey = fs.readFileSync(privateKeyPath);
+var publicKey = fs.readFileSync(publicKeyPath);
+var password = ''; // optional password
+var options = {
+  hasTimeStamp: true,
+  additionalReferences: ['wsa:Action', 'wsa:ReplyTo', 'wsa:To'],
+  signerOptions: {
+    prefix: 'ds',
+    attrs: { Id: 'Signature' },
+    existingPrefixes: {
+      wsse: 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd',
+    },
+  },
+};
+var wsSecurity = new soap.WSSecurityCert(privateKey, publicKey, password, options);
+client.setSecurity(wsSecurity);
 ```
 
 The `options` object is optional and can contain the following properties:
-* `hasTimeStamp`: Includes Timestamp tags (default: `true`)
-* `signatureTransformations`: sets the Reference Transforms Algorithm (default ['http://www.w3.org/2000/09/xmldsig#enveloped-signature', 'http://www.w3.org/2001/10/xml-exc-c14n#']). Type is a string array
-* `signatureAlgorithm`: set to `http://www.w3.org/2001/04/xmldsig-more#rsa-sha256` to use sha256
-* `digestAlgorithm`: set to `http://www.w3.org/2000/09/xmldsig#sha1` to use sha1 (default `http://www.w3.org/2001/04/xmlenc#sha256`)
-* `additionalReferences` : (optional) Array of Soap headers that need to be signed.  This need to be added using `client.addSoapHeader('header')`
-* `excludeReferencesFromSigning`: (Optional) An array of SOAP element names to exclude from signing (e.g., `Body`, `Timestamp`, `To`, `Action`).
-* `signerOptions`: (optional) passes options to the XML Signer package - from (https://github.com/yaronn/xml-crypto)
-  * `existingPrefixes`: (optional) A hash of prefixes and namespaces prefix: namespace that shouldn't be in the signature because they already exist in the xml (default: `{ 'wsse': 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' }`)
-  * `prefix`: (optional) Adds this value as a prefix for the generated signature tags.
-  * `attrs`: (optional) A hash of attributes and values attrName: value to add to the signature root node
-  * `idMode`: (optional) either 'wssecurity' to generate wsse-scoped reference Id on <Body> or undefined for an unscoped reference Id
+
+- `hasTimeStamp`: Includes Timestamp tags (default: `true`)
+- `signatureTransformations`: sets the Reference Transforms Algorithm (default ['http://www.w3.org/2000/09/xmldsig#enveloped-signature', 'http://www.w3.org/2001/10/xml-exc-c14n#']). Type is a string array
+- `signatureAlgorithm`: set to `http://www.w3.org/2001/04/xmldsig-more#rsa-sha256` to use sha256
+- `digestAlgorithm`: set to `http://www.w3.org/2000/09/xmldsig#sha1` to use sha1 (default `http://www.w3.org/2001/04/xmlenc#sha256`)
+- `additionalReferences` : (optional) Array of Soap headers that need to be signed. This need to be added using `client.addSoapHeader('header')`
+- `excludeReferencesFromSigning`: (Optional) An array of SOAP element names to exclude from signing (e.g., `Body`, `Timestamp`, `To`, `Action`).
+- `signerOptions`: (optional) passes options to the XML Signer package - from (https://github.com/yaronn/xml-crypto)
+  - `existingPrefixes`: (optional) A hash of prefixes and namespaces prefix: namespace that shouldn't be in the signature because they already exist in the xml (default: `{ 'wsse': 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' }`)
+  - `prefix`: (optional) Adds this value as a prefix for the generated signature tags.
+  - `attrs`: (optional) A hash of attributes and values attrName: value to add to the signature root node
+  - `idMode`: (optional) either 'wssecurity' to generate wsse-scoped reference Id on <Body> or undefined for an unscoped reference Id
 
 ### WSSecurityPlusCert
 
 Use WSSecurity and WSSecurityCert together.
 
-``` javascript
-  var wsSecurity = new soap.WSSecurity(/* see WSSecurity above */);
-  var wsSecurityCert = new soap.WSSecurityCert(/* see WSSecurityCert above */);
-  var wsSecurityPlusCert = new soap.WSSecurityPlusCert(wsSecurity, wsSecurityCert);
-  client.setSecurity(wsSecurityPlusCert);
+```javascript
+var wsSecurity = new soap.WSSecurity(/* see WSSecurity above */);
+var wsSecurityCert = new soap.WSSecurityCert(/* see WSSecurityCert above */);
+var wsSecurityPlusCert = new soap.WSSecurityPlusCert(wsSecurity, wsSecurityCert);
+client.setSecurity(wsSecurityPlusCert);
 ```
 
 #### Option examples
 
 `hasTimeStamp:true`
 
-``` xml
+```xml
 <soap:Header>
     <wsse:Security soap:mustUnderstand="1">
         <wsse:BinarySecurityToken>XXX</wsse:BinarySecurityToken>
@@ -1062,7 +1105,8 @@ Use WSSecurity and WSSecurityCert together.
 ```
 
 `additionalReferences: ['To']`
-``` XML
+
+```XML
 <soap:Header>
     <To Id="To">localhost.com</To>
     <wsse:Security soap:mustUnderstand="1">
@@ -1098,7 +1142,7 @@ Use WSSecurity and WSSecurityCert together.
 
 `signerOptions.prefix:'ds'`
 
-``` XML
+```XML
 <soap:Header>
     <To Id="To">localhost.com</To>
     <wsse:Security soap:mustUnderstand="1">
@@ -1134,7 +1178,7 @@ Use WSSecurity and WSSecurityCert together.
 
 `signerOptions.attrs:{ Id: 'signature-100', foo:'bar'}`
 
-``` xml
+```xml
 <soap:Header>
     <wsse:Security soap:mustUnderstand="1">
         <wsse:BinarySecurityToken>XXX</wsse:BinarySecurityToken>
@@ -1159,11 +1203,12 @@ Use WSSecurity and WSSecurityCert together.
     </wsse:Security>
 </soap:Header>
 ```
+
 ### WSSecurityCertWithToken
 
 WS-Security X509 Certificate support. Just like WSSecurityCert, except that it accepts the input properties as a single object, with two properties added `username` and `password`. Which if added, will add a UsernameToken Element to the xml security element.
 
-``` xml
+```xml
 <wsse:UsernameToken>
   <wsse:Username>someusername</wsse:Username>
   <wsse:Password>someusername's password</wsse:Password>
@@ -1173,36 +1218,44 @@ WS-Security X509 Certificate support. Just like WSSecurityCert, except that it a
 ### NTLMSecurity
 
 Parameter invocation:
-``` javascript
-  client.setSecurity(new soap.NTLMSecurity('username', 'password', 'domain', 'workstation'));
+
+```javascript
+client.setSecurity(new soap.NTLMSecurity('username', 'password', 'domain', 'workstation'));
 ```
+
 This can also be set up with a JSON object, substituting values as appropriate, for example:
-``` javascript
-  var loginData = {username: 'username', password: 'password', domain: 'domain', workstation: 'workstation'};
-  client.setSecurity(new soap.NTLMSecurity(loginData));
+
+```javascript
+var loginData = { username: 'username', password: 'password', domain: 'domain', workstation: 'workstation' };
+client.setSecurity(new soap.NTLMSecurity(loginData));
 ```
 
 ## Handling XML Attributes, Value and XML (wsdlOptions).
+
 Sometimes it is necessary to override the default behaviour of `node-soap` in order to deal with the special requirements
 of your code base or a third library you use. Therefore you can use the `wsdlOptions` Object, which is passed in the
 `#createClient()` method and could have any (or all) of the following contents:
+
 ```javascript
 var wsdlOptions = {
   attributesKey: 'theAttrs',
   valueKey: 'theVal',
-  xmlKey: 'theXml'
-}
+  xmlKey: 'theXml',
+};
 ```
+
 If nothing (or an empty Object `{}`) is passed to the `#createClient()` method, the `node-soap` defaults (`attributesKey: 'attributes'`, `valueKey: '$value'` and `xmlKey: '$xml'`) are used.
 
 ### Overriding the `value` key
+
 By default, `node-soap` uses `$value` as the key for any parsed XML value which may interfere with your other code as it
 could be some reserved word, or the `$` in general cannot be used for a key to start with.
 
 You can define your own `valueKey` by passing it in the `wsdl_options` to the createClient call:
+
 ```javascript
 var wsdlOptions = {
-  valueKey: 'theVal'
+  valueKey: 'theVal',
 };
 
 soap.createClient(__dirname + '/wsdl/default_namespace.wsdl', wsdlOptions, function (err, client) {
@@ -1211,9 +1264,11 @@ soap.createClient(__dirname + '/wsdl/default_namespace.wsdl', wsdlOptions, funct
 ```
 
 ### Overriding the `xml` key
+
 By default, `node-soap` uses `$xml` as the key to pass through an XML string as is; without parsing or namespacing it. It overrides all the other content that the node might have otherwise had.
 
 For example :
+
 ```javascript
 {
   dom: {
@@ -1232,7 +1287,9 @@ For example :
   }
 };
 ```
+
 could become
+
 ```xml
 <tns:dom>
   <tns:nodeone>
@@ -1249,9 +1306,10 @@ could become
 ```
 
 You can define your own `xmlKey` by passing it in the `wsdl_options` object to the createClient call:
+
 ```javascript
 var wsdlOptions = {
-  xmlKey: 'theXml'
+  xmlKey: 'theXml',
 };
 
 soap.createClient(__dirname + '/wsdl/default_namespace.wsdl', wsdlOptions, function (err, client) {
@@ -1260,9 +1318,10 @@ soap.createClient(__dirname + '/wsdl/default_namespace.wsdl', wsdlOptions, funct
 ```
 
 ### Overriding the `attributes` key
+
 By default, `node-soap` uses `attributes` as the key to define a nodes attributes.
 
-``` javascript
+```javascript
 {
   parentnode: {
     childnode: {
@@ -1274,23 +1333,27 @@ By default, `node-soap` uses `attributes` as the key to define a nodes attribute
   }
 }
 ```
+
 could become
-``` xml
+
+```xml
 <parentnode>
   <childnode name="childsname">Value</childnode>
 </parentnode>
 ```
 
 However, `attributes` may be a reserved key for some systems that actually want a node called `attributes`
+
 ```xml
 <attributes>
 </attributes>
 ```
 
 You can define your own `attributesKey` by passing it in the `wsdl_options` object to the createClient call:
+
 ```javascript
 var wsdlOptions = {
-  attributesKey: '$attributes'
+  attributesKey: '$attributes',
 };
 
 soap.createClient(__dirname + '/wsdl/default_namespace.wsdl', wsdlOptions, function (err, client) {
@@ -1298,11 +1361,11 @@ soap.createClient(__dirname + '/wsdl/default_namespace.wsdl', wsdlOptions, funct
     parentnode: {
       childnode: {
         $attributes: {
-          name: 'childsname'
+          name: 'childsname',
         },
-        $value: 'Value'
-      }
-    }
+        $value: 'Value',
+      },
+    },
   });
 });
 ```
@@ -1341,25 +1404,30 @@ soap.createClient('https://127.0.0.1/service.wsdl', options, function(err, clien
 ```
 
 ### Specifying the exact namespace definition of the root element
+
 In rare cases, you may want to precisely control the namespace definition that is included in the root element.
 
 You can specify the namespace definitions by setting the `overrideRootElement` key in the `wsdlOptions` like so:
+
 ```javascript
 var wsdlOptions = {
   overrideRootElement: {
     namespace: 'xmlns:tns',
-    xmlnsAttributes: [{
-      name: 'xmlns:ns2',
-      value: "http://tempuri.org/"
-    }, {
-      name: 'xmlns:ns3',
-      value: "http://sillypets.com/xsd"
-    }]
-  }
+    xmlnsAttributes: [
+      {
+        name: 'xmlns:ns2',
+        value: 'http://tempuri.org/',
+      },
+      {
+        name: 'xmlns:ns3',
+        value: 'http://sillypets.com/xsd',
+      },
+    ],
+  },
 };
 ```
 
-To see it in practice, have a look at the sample files in: [test/request-response-samples/addPets__force_namespaces](https://github.com/vpulim/node-soap/tree/master/test/request-response-samples/addPets__force_namespaces)
+To see it in practice, have a look at the sample files in: [test/request-response-samples/addPets\_\_force_namespaces](https://github.com/vpulim/node-soap/tree/master/test/request-response-samples/addPets__force_namespaces)
 
 ### Overriding element key specification in XML
 
@@ -1367,6 +1435,7 @@ In very rare cases ([external implementation isn't matching exactly the WSDL spe
 you may want to override element XML keys in requests and/or responses.
 
 You can specify the key definitions by setting the `overrideElementKey` key in the `wsdlOptions` like so:
+
 ```javascript
 var wsdlOptions = {
   overrideElementKey: {
@@ -1377,7 +1446,7 @@ var wsdlOptions = {
 };
 ```
 
-Test sample files covering this are in [test/request-response-samples/Dummy__ref_element_should_have_correct_namespace_with_overrideElementKey](https://github.com/vpulim/node-soap/tree/master/test/request-response-samples/Dummy__ref_element_should_have_correct_namespace_with_overrideElementKey)
+Test sample files covering this are in [test/request-response-samples/Dummy\_\_ref_element_should_have_correct_namespace_with_overrideElementKey](https://github.com/vpulim/node-soap/tree/master/test/request-response-samples/Dummy__ref_element_should_have_correct_namespace_with_overrideElementKey)
 
 ### Custom Deserializer
 
@@ -1387,6 +1456,7 @@ For example if the soap response contains dates that are not in a format recogni
 To do so, you can pass a `customDeserializer` object in `options`. The properties of this object are the types that your deserializer handles itself.
 
 Example :
+
 ```javascript
 
    var wsdlOptions = {
@@ -1417,134 +1487,89 @@ Example :
 ```
 
 ### Changing the tag formats to use self-closing (empty element) tags
+
 The XML specification specifies that there is no semantic difference between `<Tag></Tag>` and `<Tag />`, and node-soap defaults to using the `<Tag></Tag>` format. But if your web service is particular, or if there is a stylistic preference, the `useEmptyTag` option causes tags with no contents to use the `<Tag />` format instead.
 
 ```javascript
 var wsdlOptions = {
-  useEmptyTag: true
+  useEmptyTag: true,
 };
 ```
 
 For example: `{ MyTag: { attributes: { MyAttr: 'value' } } }` is:
 
-* **Without useEmptyTag**: `<MyTag MyAttr="value"></MyTag>`
-* **With useEmptyTag set to true**: `<MyTag MyAttr="value" />`
+- **Without useEmptyTag**: `<MyTag MyAttr="value"></MyTag>`
+- **With useEmptyTag set to true**: `<MyTag MyAttr="value" />`
 
 ## Handling "ignored" namespaces
+
 If an Element in a `schema` definition depends on an Element which is present in the same namespace, normally the `tns:`
 namespace prefix is used to identify this Element. This is not much of a problem as long as you have just one `schema` defined
 (inline or in a separate file). If there are more `schema` files, the `tns:` in the generated `soap` file resolved mostly to the parent `wsdl` file,
- which was obviously wrong.
-
- `node-soap` now handles namespace prefixes which shouldn't be resolved (because it's not necessary) as so called `ignoredNamespaces`
- which default to an Array of 3 Strings (`['tns', 'targetNamespace', 'typedNamespace']`).
-
- If this is not sufficient for your purpose you can easily add more namespace prefixes to this Array, or override it in its entirety
- by passing an `ignoredNamespaces` object within the `options` you pass in `soap.createClient()` method.
-
- A simple `ignoredNamespaces` object, which only adds certain namespaces could look like this:
- ```
- var options = {
-   ignoredNamespaces: {
-     namespaces: ['namespaceToIgnore', 'someOtherNamespace']
-   }
- }
- ```
- This would extend the `ignoredNamespaces` of the `WSDL` processor to `['tns', 'targetNamespace', 'typedNamespace', 'namespaceToIgnore', 'someOtherNamespace']`.
-
- If you want to override the default ignored namespaces you would simply pass the following `ignoredNamespaces` object within the `options`:
- ```
- var options = {
-     ignoredNamespaces: {
-       namespaces: ['namespaceToIgnore', 'someOtherNamespace'],
-       override: true
-     }
-   }
- ```
- This would override the default `ignoredNamespaces` of the `WSDL` processor to `['namespaceToIgnore', 'someOtherNamespace']`. (This shouldn't be necessary, anyways).
+which was obviously wrong.
 
-## Handling "ignoreBaseNameSpaces" attribute
-If an Element in a `schema` definition depends has a basenamespace defined but the request does not need that value, for example you have a "sentJob" with basenamespace "v20"
-but the request need only: <sendJob> set in the tree structure, you need to set the ignoreBaseNameSpaces to true. This is set because in a lot of workaround the wsdl structure is not correctly
-set or the webservice bring errors.
+`node-soap` now handles namespace prefixes which shouldn't be resolved (because it's not necessary) as so called `ignoredNamespaces`
+which default to an Array of 3 Strings (`['tns', 'targetNamespace', 'typedNamespace']`).
 
-By default the attribute is set to true.
-An example to use:
+If this is not sufficient for your purpose you can easily add more namespace prefixes to this Array, or override it in its entirety
+by passing an `ignoredNamespaces` object within the `options` you pass in `soap.createClient()` method.
 
 A simple `ignoredNamespaces` object, which only adds certain namespaces could look like this:
+
 ```
 var options = {
-ignoredNamespaces: true
+  ignoredNamespaces: {
+    namespaces: ['namespaceToIgnore', 'someOtherNamespace']
+  }
 }
 ```
 
-## soap-stub
-
-Unit testing services that use soap clients can be very cumbersome.  In order to get
-around this you can use `soap-stub` in conjunction with `sinon` to stub soap with
-your clients.
-
-### Example
-
-```javascript
-// test-initialization-script.js
-var sinon = require('sinon');
-var soapStub = require('soap/soap-stub');
+This would extend the `ignoredNamespaces` of the `WSDL` processor to `['tns', 'targetNamespace', 'typedNamespace', 'namespaceToIgnore', 'someOtherNamespace']`.
 
-var urlMyApplicationWillUseWithCreateClient = 'http://path-to-my-wsdl';
-var clientStub = {
-  SomeOperation: sinon.stub()
-};
+If you want to override the default ignored namespaces you would simply pass the following `ignoredNamespaces` object within the `options`:
 
-clientStub.SomeOperation.respondWithError = soapStub.createErroringStub({..error json...});
-clientStub.SomeOperation.respondWithSuccess = soapStub.createRespondingStub({..success json...});
+```
+var options = {
+    ignoredNamespaces: {
+      namespaces: ['namespaceToIgnore', 'someOtherNamespace'],
+      override: true
+    }
+  }
+```
 
-soapStub.registerClient('my client alias', urlMyApplicationWillUseWithCreateClient, clientStub);
+This would override the default `ignoredNamespaces` of the `WSDL` processor to `['namespaceToIgnore', 'someOtherNamespace']`. (This shouldn't be necessary, anyways).
 
-// test.js
-var soapStub = require('soap/soap-stub');
+## Handling "ignoreBaseNameSpaces" attribute
 
-describe('myService', function() {
-  var clientStub;
-  var myService;
+If an Element in a `schema` definition depends has a basenamespace defined but the request does not need that value, for example you have a "sentJob" with basenamespace "v20"
+but the request need only: <sendJob> set in the tree structure, you need to set the ignoreBaseNameSpaces to true. This is set because in a lot of workaround the wsdl structure is not correctly
+set or the webservice bring errors.
 
-  beforeEach(function() {
-    clientStub = soapStub.getStub('my client alias');
-    soapStub.reset();
-    myService.init(clientStub);
-  });
+By default the attribute is set to true.
+An example to use:
 
-  describe('failures', function() {
-    beforeEach(function() {
-      clientStub.SomeOperation.respondWithError();
-    });
+A simple `ignoredNamespaces` object, which only adds certain namespaces could look like this:
 
-    it('should handle error responses', function() {
-      myService.somethingThatCallsSomeOperation(function(err, response) {
-        // handle the error response.
-      });
-    });
-  });
-});
 ```
-
+var options = {
+ignoredNamespaces: true
+}
+```
 
 ## Contributors
 
- * Author: [Vinay Pulim](https://github.com/vpulim)
- * Active maintainers:
-   - [Vasily Martynov](https://github.com/w666)
- * Previous maintainers (not active for a long time):
-   - [Joe Spencer](https://github.com/jsdevel)
-   - [Heinz Romirer](https://github.com/herom)
- * [All Contributors](https://github.com/vpulim/node-soap/graphs/contributors)
+- Author: [Vinay Pulim](https://github.com/vpulim)
+- Active maintainers:
+  - [Vasily Martynov](https://github.com/w666)
+- Previous maintainers (not active for a long time):
+  - [Joe Spencer](https://github.com/jsdevel)
+  - [Heinz Romirer](https://github.com/herom)
+- [All Contributors](https://github.com/vpulim/node-soap/graphs/contributors)
 
 [downloads-image]: http://img.shields.io/npm/dm/soap.svg
 [npm-url]: https://npmjs.org/package/soap
 [npm-image]: http://img.shields.io/npm/v/soap.svg
-
 [coveralls-url]: https://coveralls.io/r/vpulim/node-soap
 [coveralls-image]: http://img.shields.io/coveralls/vpulim/node-soap/master.svg
-
 [buy-me-a-coffee-url]: https://coff.ee/vasily.m
 [buy-me-a-coffee-image]: https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png