How to use the xml function in xml

getXml(options) {
        const urlElements = this.generateSiteMapUrlElements(options)
        const data = {
            // Concat the elements to the _attr declaration
            sitemapindex: [XMLNS_DECLS].concat(urlElements),
        }

        // Return the xml
        return localUtils.getDeclarations(options) + xml(data)
    }

// Using negative here to sort newest to oldest
                ts: -(self.nodeTimeLookup[id] || 0),
                node: node,
            }
        }, [])
        // Sort nodes by timestamp
        const sortedNodes = _.sortBy(timedNodes, `ts`)
        // Grab just the nodes
        const urlElements = _.map(sortedNodes, `node`)
        const data = {
            // Concat the elements to the _attr declaration
            urlset: [XMLNS_DECLS].concat(urlElements),
        }

        // Return the xml
        return localUtils.getDeclarations(options) + xml(data)
    }

var query = `uploadId=${uriEscape(uploadId)}`

    var parts = []

    etags.forEach(element => {
      parts.push({
        Part: [{
          PartNumber: element.part
        }, {
          ETag: element.etag
        }]
      })
    })

    var payloadObject = {CompleteMultipartUpload: parts}
    var payload = Xml(payloadObject)

    this.makeRequest({method, bucketName, objectName, query}, payload, 200, '', true, (e, response) => {
      if (e) return cb(e)
      var transformer = transformers.getCompleteMultipartTransformer()
      pipesetup(response, transformer)
        .on('error', e => cb(e))
        .on('data', result => {
          if (result.errCode) {
            // Multipart Complete API returns an error XML after a 200 http status
            cb(new errors.S3Error(result.errMessage))
          } else {
            cb(null, result.etag)
          }
        })
    })
  }

export function createXMLExample(schema, config) {
  let json = sampleXmlFromSchema(schema, config)
  if (!json) { return }

  return XML(json, { declaration: true, indent: "\t" })
}

{ "_attr": { "allow-credentials": corsPolicy.allowCredentials } },
                { "allowed-origins": origins },
                { "allowed-methods": methods },
                { "allowed-headers": allowedHeaders },
                { "expose-headers": exposeHeaders },
              ]
            }
          ],
        },
        { backend: [{ base: null }] },
        { outbound: [{ base: null }] },
        { "on-error": [{ base: null }] },
      ]
    }];

    return xml(policy, { indent: "\t" });
  }

function sitemapXml() {
  const pages = [...Scrivito.Obj.where('_objClass', 'equals', OBJ_CLASSES_WHITELIST)
    .andNot('robotsIndex', 'equals', 'no')];
  const sitemapUrls = pages.map(pageToSitemapUrl);

  return xml(
    {
      urlset: [
        { _attr: { xmlns: 'http://www.sitemaps.org/schemas/sitemap/0.9' } },
        ...sitemapUrls,
      ],
    },
    { declaration: true }
  );
}

async.eachSeries(result.listOfList, (list, callback) => {
      var deleteObjects={"Delete":[{"Quiet": true}]}

      list.forEach(function(value){
        deleteObjects["Delete"].push({"Object": [{"Key": value}]})
      })

      let payload = Xml(deleteObjects)

      var headers = {}
      var md5digest = Crypto.createHash('md5').update(payload).digest()

      headers['Content-MD5'] = md5digest.toString('base64')

      this.makeRequest({ method, bucketName, query, headers}, payload, 200, '', false, (e) => {
        if (e) return callback(e)
        callback(null)
      })
    }, cb)
  }

if(entry.image) {
        item.push({ enclosure: [{ _attr: { url: entry.image } }] });
      }

      channel.push({ item });
    })

    if(isContent) {
      rss[0]._attr['xmlns:content'] = 'http://purl.org/rss/1.0/modules/content/';
    }

    if(isAtom) {
      rss[0]._attr['xmlns:atom'] = 'http://www.w3.org/2005/Atom';
    }

    return DOCTYPE + xml(root, true);
  }

parts = []

  etags.forEach(element => {
    parts.push({
      Part: [{
        PartNumber: element.part
      }, {
        ETag: element.etag
      }]
    })
  })

  var payloadObject = {
      CompleteMultipartUpload: parts
    },
    payload = Xml(payloadObject),
    hash = Crypto.createHash('sha256')

  hash.update(payload)

  var sha256 = hash.digest('hex').toLowerCase(),
    stream = new Stream.Readable()

  stream._read = function() {}
  stream.push(payload)
  stream.push(null)

  signV4(requestParams, sha256, params.accessKey, params.secretKey)

  var request = transport.request(requestParams, (response) => {
    if (response.statusCode !== 200) {
      return parseError(response, cb)