text: # coding: utf-8
  
  """
      convertapi
  
      Convert API lets you effortlessly convert file formats and types.  # noqa: E501
  
      OpenAPI spec version: v1
      
      Generated by: https://github.com/swagger-api/swagger-codegen.git
  """
  
  
  from __future__ import absolute_import
  
  import re  # noqa: F401
  
  # python 2 and python 3 compatibility library
  import six
  
  from cloudmersive_convert_api_client.api_client import ApiClient
  
  
  class ConvertDataApi(object):
      """NOTE: This class is auto generated by the swagger code generator program.
  
      Do not edit the class manually.
      Ref: https://github.com/swagger-api/swagger-codegen
      """
  
      def __init__(self, api_client=None):
          if api_client is None:
              api_client = ApiClient()
          self.api_client = api_client
  
      def convert_data_csv_to_json(self, input_file, **kwargs):  # noqa: E501
          """Convert CSV to JSON conversion  # noqa: E501
  
          Convert a CSV file to a JSON object array  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_csv_to_json(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :param bool column_names_from_first_row: Optional; If true, the first row will be used as the labels for the columns; if false, columns will be named Column0, Column1, etc.  Default is true.  Set to false if you are not using column headings, or have an irregular column structure.
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_csv_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_csv_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_csv_to_json_with_http_info(self, input_file, **kwargs):  # noqa: E501
          """Convert CSV to JSON conversion  # noqa: E501
  
          Convert a CSV file to a JSON object array  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_csv_to_json_with_http_info(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :param bool column_names_from_first_row: Optional; If true, the first row will be used as the labels for the columns; if false, columns will be named Column0, Column1, etc.  Default is true.  Set to false if you are not using column headings, or have an irregular column structure.
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'column_names_from_first_row']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_csv_to_json" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_csv_to_json`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'column_names_from_first_row' in params:
              header_params['columnNamesFromFirstRow'] = params['column_names_from_first_row']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/csv/to/json', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='object',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_csv_to_xml(self, input_file, **kwargs):  # noqa: E501
          """Convert CSV to XML conversion  # noqa: E501
  
          Convert a CSV file to a XML file  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_csv_to_xml(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :param bool column_names_from_first_row: Optional; If true, the first row will be used as the labels for the columns; if false, columns will be named Column0, Column1, etc.  Default is true.  Set to false if you are not using column headings, or have an irregular column structure.
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_csv_to_xml_with_http_info(input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_csv_to_xml_with_http_info(input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_csv_to_xml_with_http_info(self, input_file, **kwargs):  # noqa: E501
          """Convert CSV to XML conversion  # noqa: E501
  
          Convert a CSV file to a XML file  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_csv_to_xml_with_http_info(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :param bool column_names_from_first_row: Optional; If true, the first row will be used as the labels for the columns; if false, columns will be named Column0, Column1, etc.  Default is true.  Set to false if you are not using column headings, or have an irregular column structure.
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'column_names_from_first_row']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_csv_to_xml" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_csv_to_xml`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'column_names_from_first_row' in params:
              header_params['columnNamesFromFirstRow'] = params['column_names_from_first_row']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/octet-stream'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/csv/to/xml', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_json_string_to_xml(self, json_string, **kwargs):  # noqa: E501
          """Convert JSON String to XML conversion  # noqa: E501
  
          Convert a JSON object into XML  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_json_string_to_xml(json_string, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str json_string: Input JSON String to convert to XML (required)
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_json_string_to_xml_with_http_info(json_string, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_json_string_to_xml_with_http_info(json_string, **kwargs)  # noqa: E501
              return data
  
      def convert_data_json_string_to_xml_with_http_info(self, json_string, **kwargs):  # noqa: E501
          """Convert JSON String to XML conversion  # noqa: E501
  
          Convert a JSON object into XML  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_json_string_to_xml_with_http_info(json_string, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str json_string: Input JSON String to convert to XML (required)
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['json_string']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_json_string_to_xml" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'json_string' is set
          if ('json_string' not in params or
                  params['json_string'] is None):
              raise ValueError("Missing the required parameter `json_string` when calling `convert_data_json_string_to_xml`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'json_string' in params:
              query_params.append(('JsonString', params['json_string']))  # noqa: E501
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/json-string/to/xml', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='object',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_json_to_xml(self, json_object, **kwargs):  # noqa: E501
          """Convert JSON Object to XML conversion  # noqa: E501
  
          Convert a JSON object into XML  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_json_to_xml(json_object, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param object json_object: Input JSON Object to convert to XML (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_json_to_xml_with_http_info(json_object, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_json_to_xml_with_http_info(json_object, **kwargs)  # noqa: E501
              return data
  
      def convert_data_json_to_xml_with_http_info(self, json_object, **kwargs):  # noqa: E501
          """Convert JSON Object to XML conversion  # noqa: E501
  
          Convert a JSON object into XML  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_json_to_xml_with_http_info(json_object, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param object json_object: Input JSON Object to convert to XML (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['json_object']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_json_to_xml" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'json_object' is set
          if ('json_object' not in params or
                  params['json_object'] is None):
              raise ValueError("Missing the required parameter `json_object` when calling `convert_data_json_to_xml`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'json_object' in params:
              body_params = params['json_object']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/xml'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['application/json', 'text/json', 'application/xml', 'text/xml', 'application/x-www-form-urlencoded'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/json/to/xml', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xls_to_json(self, input_file, **kwargs):  # noqa: E501
          """Convert Excel (97-2003) XLS to JSON conversion  # noqa: E501
  
          Convert an Excel (97-2003) XLS file to a JSON object array  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xls_to_json(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xls_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xls_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xls_to_json_with_http_info(self, input_file, **kwargs):  # noqa: E501
          """Convert Excel (97-2003) XLS to JSON conversion  # noqa: E501
  
          Convert an Excel (97-2003) XLS file to a JSON object array  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xls_to_json_with_http_info(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xls_to_json" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xls_to_json`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xls/to/json', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='object',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xlsx_to_json(self, input_file, **kwargs):  # noqa: E501
          """Convert Excel XLSX to JSON conversion  # noqa: E501
  
          Convert an Excel XLSX file to a JSON object array  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xlsx_to_json(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xlsx_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xlsx_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xlsx_to_json_with_http_info(self, input_file, **kwargs):  # noqa: E501
          """Convert Excel XLSX to JSON conversion  # noqa: E501
  
          Convert an Excel XLSX file to a JSON object array  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xlsx_to_json_with_http_info(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xlsx_to_json" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xlsx_to_json`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/octet-stream'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xlsx/to/json', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xlsx_to_xml(self, input_file, **kwargs):  # noqa: E501
          """Convert Excel XLSX to XML conversion  # noqa: E501
  
          Convert an Excel XLSX file to a XML file  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xlsx_to_xml(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xlsx_to_xml_with_http_info(input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xlsx_to_xml_with_http_info(input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xlsx_to_xml_with_http_info(self, input_file, **kwargs):  # noqa: E501
          """Convert Excel XLSX to XML conversion  # noqa: E501
  
          Convert an Excel XLSX file to a XML file  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xlsx_to_xml_with_http_info(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xlsx_to_xml" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xlsx_to_xml`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/octet-stream'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xlsx/to/xml', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_edit_add_attribute_with_x_path(self, input_file, x_path_expression, xml_attribute_name, xml_attribute_value, **kwargs):  # noqa: E501
          """Adds an attribute to all XML nodes matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by adding an attribute to all of the nodes that match an input XPath expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_add_attribute_with_x_path(input_file, x_path_expression, xml_attribute_name, xml_attribute_value, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_attribute_name: Name of the XML attribute to add (required)
          :param str xml_attribute_value: Value of the XML attribute to add (required)
          :return: XmlAddAttributeWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_edit_add_attribute_with_x_path_with_http_info(input_file, x_path_expression, xml_attribute_name, xml_attribute_value, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_edit_add_attribute_with_x_path_with_http_info(input_file, x_path_expression, xml_attribute_name, xml_attribute_value, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_edit_add_attribute_with_x_path_with_http_info(self, input_file, x_path_expression, xml_attribute_name, xml_attribute_value, **kwargs):  # noqa: E501
          """Adds an attribute to all XML nodes matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by adding an attribute to all of the nodes that match an input XPath expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_add_attribute_with_x_path_with_http_info(input_file, x_path_expression, xml_attribute_name, xml_attribute_value, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_attribute_name: Name of the XML attribute to add (required)
          :param str xml_attribute_value: Value of the XML attribute to add (required)
          :return: XmlAddAttributeWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'x_path_expression', 'xml_attribute_name', 'xml_attribute_value']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_edit_add_attribute_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_edit_add_attribute_with_x_path`")  # noqa: E501
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_edit_add_attribute_with_x_path`")  # noqa: E501
          # verify the required parameter 'xml_attribute_name' is set
          if ('xml_attribute_name' not in params or
                  params['xml_attribute_name'] is None):
              raise ValueError("Missing the required parameter `xml_attribute_name` when calling `convert_data_xml_edit_add_attribute_with_x_path`")  # noqa: E501
          # verify the required parameter 'xml_attribute_value' is set
          if ('xml_attribute_value' not in params or
                  params['xml_attribute_value'] is None):
              raise ValueError("Missing the required parameter `xml_attribute_value` when calling `convert_data_xml_edit_add_attribute_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
          if 'xml_attribute_name' in params:
              header_params['XmlAttributeName'] = params['xml_attribute_name']  # noqa: E501
          if 'xml_attribute_value' in params:
              header_params['XmlAttributeValue'] = params['xml_attribute_value']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/edit/xpath/add-attribute', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlAddAttributeWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_edit_add_child_with_x_path(self, input_file, x_path_expression, xml_node_to_add, **kwargs):  # noqa: E501
          """Adds an XML node as a child to XML nodes matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by adding an XML node as a child to all of the nodes that match an input XPath expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_add_child_with_x_path(input_file, x_path_expression, xml_node_to_add, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_node_to_add: XML Node to add as a child (required)
          :return: XmlAddChildWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_edit_add_child_with_x_path_with_http_info(input_file, x_path_expression, xml_node_to_add, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_edit_add_child_with_x_path_with_http_info(input_file, x_path_expression, xml_node_to_add, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_edit_add_child_with_x_path_with_http_info(self, input_file, x_path_expression, xml_node_to_add, **kwargs):  # noqa: E501
          """Adds an XML node as a child to XML nodes matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by adding an XML node as a child to all of the nodes that match an input XPath expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_add_child_with_x_path_with_http_info(input_file, x_path_expression, xml_node_to_add, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_node_to_add: XML Node to add as a child (required)
          :return: XmlAddChildWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'x_path_expression', 'xml_node_to_add']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_edit_add_child_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_edit_add_child_with_x_path`")  # noqa: E501
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_edit_add_child_with_x_path`")  # noqa: E501
          # verify the required parameter 'xml_node_to_add' is set
          if ('xml_node_to_add' not in params or
                  params['xml_node_to_add'] is None):
              raise ValueError("Missing the required parameter `xml_node_to_add` when calling `convert_data_xml_edit_add_child_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
          if 'xml_node_to_add' in params:
              header_params['XmlNodeToAdd'] = params['xml_node_to_add']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/edit/xpath/add-child', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlAddChildWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_edit_remove_all_child_nodes_with_x_path(self, input_file, x_path_expression, **kwargs):  # noqa: E501
          """Removes, deletes all children of nodes matching XPath expression, but does not remove the nodes  # noqa: E501
  
          Return the reuslts of editing an XML document by removing all child nodes of the nodes that match an input XPath expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_remove_all_child_nodes_with_x_path(input_file, x_path_expression, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :return: XmlRemoveAllChildrenWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_edit_remove_all_child_nodes_with_x_path_with_http_info(input_file, x_path_expression, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_edit_remove_all_child_nodes_with_x_path_with_http_info(input_file, x_path_expression, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_edit_remove_all_child_nodes_with_x_path_with_http_info(self, input_file, x_path_expression, **kwargs):  # noqa: E501
          """Removes, deletes all children of nodes matching XPath expression, but does not remove the nodes  # noqa: E501
  
          Return the reuslts of editing an XML document by removing all child nodes of the nodes that match an input XPath expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_remove_all_child_nodes_with_x_path_with_http_info(input_file, x_path_expression, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :return: XmlRemoveAllChildrenWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'x_path_expression']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_edit_remove_all_child_nodes_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_edit_remove_all_child_nodes_with_x_path`")  # noqa: E501
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_edit_remove_all_child_nodes_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/edit/xpath/remove-all-children', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlRemoveAllChildrenWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_edit_replace_with_x_path(self, input_file, x_path_expression, xml_node_replacement, **kwargs):  # noqa: E501
          """Replaces XML nodes matching XPath expression with new node  # noqa: E501
  
          Return the reuslts of editing an XML document by replacing all of the nodes that match an input XPath expression with a new XML node expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_replace_with_x_path(input_file, x_path_expression, xml_node_replacement, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_node_replacement: XML Node replacement content (required)
          :return: XmlReplaceWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_edit_replace_with_x_path_with_http_info(input_file, x_path_expression, xml_node_replacement, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_edit_replace_with_x_path_with_http_info(input_file, x_path_expression, xml_node_replacement, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_edit_replace_with_x_path_with_http_info(self, input_file, x_path_expression, xml_node_replacement, **kwargs):  # noqa: E501
          """Replaces XML nodes matching XPath expression with new node  # noqa: E501
  
          Return the reuslts of editing an XML document by replacing all of the nodes that match an input XPath expression with a new XML node expression.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_replace_with_x_path_with_http_info(input_file, x_path_expression, xml_node_replacement, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_node_replacement: XML Node replacement content (required)
          :return: XmlReplaceWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'x_path_expression', 'xml_node_replacement']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_edit_replace_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_edit_replace_with_x_path`")  # noqa: E501
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_edit_replace_with_x_path`")  # noqa: E501
          # verify the required parameter 'xml_node_replacement' is set
          if ('xml_node_replacement' not in params or
                  params['xml_node_replacement'] is None):
              raise ValueError("Missing the required parameter `xml_node_replacement` when calling `convert_data_xml_edit_replace_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
          if 'xml_node_replacement' in params:
              header_params['XmlNodeReplacement'] = params['xml_node_replacement']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/edit/xpath/replace', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlReplaceWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_edit_set_value_with_x_path(self, input_file, x_path_expression, xml_value, **kwargs):  # noqa: E501
          """Sets the value contents of XML nodes matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by setting the contents of all of the nodes that match an input XPath expression.  Supports elements and attributes.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_set_value_with_x_path(input_file, x_path_expression, xml_value, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_value: XML Value to set into the matching XML nodes (required)
          :return: XmlSetValueWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_edit_set_value_with_x_path_with_http_info(input_file, x_path_expression, xml_value, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_edit_set_value_with_x_path_with_http_info(input_file, x_path_expression, xml_value, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_edit_set_value_with_x_path_with_http_info(self, input_file, x_path_expression, xml_value, **kwargs):  # noqa: E501
          """Sets the value contents of XML nodes matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by setting the contents of all of the nodes that match an input XPath expression.  Supports elements and attributes.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_edit_set_value_with_x_path_with_http_info(input_file, x_path_expression, xml_value, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param str xml_value: XML Value to set into the matching XML nodes (required)
          :return: XmlSetValueWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'x_path_expression', 'xml_value']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_edit_set_value_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_edit_set_value_with_x_path`")  # noqa: E501
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_edit_set_value_with_x_path`")  # noqa: E501
          # verify the required parameter 'xml_value' is set
          if ('xml_value' not in params or
                  params['xml_value'] is None):
              raise ValueError("Missing the required parameter `xml_value` when calling `convert_data_xml_edit_set_value_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
          if 'xml_value' in params:
              header_params['XmlValue'] = params['xml_value']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/edit/xpath/set-value', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlSetValueWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_filter_with_x_path(self, x_path_expression, input_file, **kwargs):  # noqa: E501
          """Filter, select XML nodes using XPath expression, get results  # noqa: E501
  
          Return the reuslts of filtering, selecting an XML document with an XPath expression  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_filter_with_x_path(x_path_expression, input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param file input_file: Input file to perform the operation on. (required)
          :return: XmlFilterWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_filter_with_x_path_with_http_info(x_path_expression, input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_filter_with_x_path_with_http_info(x_path_expression, input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_filter_with_x_path_with_http_info(self, x_path_expression, input_file, **kwargs):  # noqa: E501
          """Filter, select XML nodes using XPath expression, get results  # noqa: E501
  
          Return the reuslts of filtering, selecting an XML document with an XPath expression  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_filter_with_x_path_with_http_info(x_path_expression, input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param file input_file: Input file to perform the operation on. (required)
          :return: XmlFilterWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['x_path_expression', 'input_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_filter_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_filter_with_x_path`")  # noqa: E501
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_filter_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/select/xpath', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlFilterWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_query_with_x_query(self, input_file, x_query, **kwargs):  # noqa: E501
          """Query an XML file using XQuery query, get results  # noqa: E501
  
          Return the reuslts of querying a single XML document with an XQuery expression.  Supports XQuery 3.1 and earlier.  This API is optimized for a single XML document as input.  Provided XML document is automatically loaded as the default context; to access elements in the document, simply refer to them without a document reference, such as bookstore/book  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_query_with_x_query(input_file, x_query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_query: Valid XML XQuery 3.1 or earlier query expression; multi-line expressions are supported (required)
          :return: XmlQueryWithXQueryResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_query_with_x_query_with_http_info(input_file, x_query, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_query_with_x_query_with_http_info(input_file, x_query, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_query_with_x_query_with_http_info(self, input_file, x_query, **kwargs):  # noqa: E501
          """Query an XML file using XQuery query, get results  # noqa: E501
  
          Return the reuslts of querying a single XML document with an XQuery expression.  Supports XQuery 3.1 and earlier.  This API is optimized for a single XML document as input.  Provided XML document is automatically loaded as the default context; to access elements in the document, simply refer to them without a document reference, such as bookstore/book  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_query_with_x_query_with_http_info(input_file, x_query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param str x_query: Valid XML XQuery 3.1 or earlier query expression; multi-line expressions are supported (required)
          :return: XmlQueryWithXQueryResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'x_query']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_query_with_x_query" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_query_with_x_query`")  # noqa: E501
          # verify the required parameter 'x_query' is set
          if ('x_query' not in params or
                  params['x_query'] is None):
              raise ValueError("Missing the required parameter `x_query` when calling `convert_data_xml_query_with_x_query`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_query' in params:
              header_params['XQuery'] = params['x_query']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/query/xquery', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlQueryWithXQueryResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_query_with_x_query_multi(self, input_file1, x_query, **kwargs):  # noqa: E501
          """Query multiple XML files using XQuery query, get results  # noqa: E501
  
          Return the reuslts of querying an XML document with an XQuery expression.  Supports XQuery 3.1 and earlier.  This API is optimized for multiple XML documents as input.  You can refer to the contents of a given document by name, for example doc(\"books.xml\") or doc(\"restaurants.xml\") if you included two input files named books.xml and restaurants.xml.  If input files contain no file name, they will default to file names input1.xml, input2.xml and so on.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_query_with_x_query_multi(input_file1, x_query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file1: First input XML file to perform the operation on. (required)
          :param str x_query: Valid XML XQuery 3.1 or earlier query expression; multi-line expressions are supported (required)
          :param file input_file2: Second input XML file to perform the operation on.
          :param file input_file3: Third input XML file to perform the operation on.
          :param file input_file4: Fourth input XML file to perform the operation on.
          :param file input_file5: Fifth input XML file to perform the operation on.
          :param file input_file6: Sixth input XML file to perform the operation on.
          :param file input_file7: Seventh input XML file to perform the operation on.
          :param file input_file8: Eighth input XML file to perform the operation on.
          :param file input_file9: Ninth input XML file to perform the operation on.
          :param file input_file10: Tenth input XML file to perform the operation on.
          :return: XmlQueryWithXQueryMultiResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_query_with_x_query_multi_with_http_info(input_file1, x_query, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_query_with_x_query_multi_with_http_info(input_file1, x_query, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_query_with_x_query_multi_with_http_info(self, input_file1, x_query, **kwargs):  # noqa: E501
          """Query multiple XML files using XQuery query, get results  # noqa: E501
  
          Return the reuslts of querying an XML document with an XQuery expression.  Supports XQuery 3.1 and earlier.  This API is optimized for multiple XML documents as input.  You can refer to the contents of a given document by name, for example doc(\"books.xml\") or doc(\"restaurants.xml\") if you included two input files named books.xml and restaurants.xml.  If input files contain no file name, they will default to file names input1.xml, input2.xml and so on.  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_query_with_x_query_multi_with_http_info(input_file1, x_query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file1: First input XML file to perform the operation on. (required)
          :param str x_query: Valid XML XQuery 3.1 or earlier query expression; multi-line expressions are supported (required)
          :param file input_file2: Second input XML file to perform the operation on.
          :param file input_file3: Third input XML file to perform the operation on.
          :param file input_file4: Fourth input XML file to perform the operation on.
          :param file input_file5: Fifth input XML file to perform the operation on.
          :param file input_file6: Sixth input XML file to perform the operation on.
          :param file input_file7: Seventh input XML file to perform the operation on.
          :param file input_file8: Eighth input XML file to perform the operation on.
          :param file input_file9: Ninth input XML file to perform the operation on.
          :param file input_file10: Tenth input XML file to perform the operation on.
          :return: XmlQueryWithXQueryMultiResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file1', 'x_query', 'input_file2', 'input_file3', 'input_file4', 'input_file5', 'input_file6', 'input_file7', 'input_file8', 'input_file9', 'input_file10']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_query_with_x_query_multi" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file1' is set
          if ('input_file1' not in params or
                  params['input_file1'] is None):
              raise ValueError("Missing the required parameter `input_file1` when calling `convert_data_xml_query_with_x_query_multi`")  # noqa: E501
          # verify the required parameter 'x_query' is set
          if ('x_query' not in params or
                  params['x_query'] is None):
              raise ValueError("Missing the required parameter `x_query` when calling `convert_data_xml_query_with_x_query_multi`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_query' in params:
              header_params['XQuery'] = params['x_query']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file1' in params:
              local_var_files['inputFile1'] = params['input_file1']  # noqa: E501
          if 'input_file2' in params:
              local_var_files['inputFile2'] = params['input_file2']  # noqa: E501
          if 'input_file3' in params:
              local_var_files['inputFile3'] = params['input_file3']  # noqa: E501
          if 'input_file4' in params:
              local_var_files['inputFile4'] = params['input_file4']  # noqa: E501
          if 'input_file5' in params:
              local_var_files['inputFile5'] = params['input_file5']  # noqa: E501
          if 'input_file6' in params:
              local_var_files['inputFile6'] = params['input_file6']  # noqa: E501
          if 'input_file7' in params:
              local_var_files['inputFile7'] = params['input_file7']  # noqa: E501
          if 'input_file8' in params:
              local_var_files['inputFile8'] = params['input_file8']  # noqa: E501
          if 'input_file9' in params:
              local_var_files['inputFile9'] = params['input_file9']  # noqa: E501
          if 'input_file10' in params:
              local_var_files['inputFile10'] = params['input_file10']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/query/xquery/multi', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlQueryWithXQueryMultiResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_remove_with_x_path(self, x_path_expression, input_file, **kwargs):  # noqa: E501
          """Remove, delete XML nodes and items matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by removing all of the nodes that match an input XPath expression  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_remove_with_x_path(x_path_expression, input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param file input_file: Input file to perform the operation on. (required)
          :return: XmlRemoveWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_remove_with_x_path_with_http_info(x_path_expression, input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_remove_with_x_path_with_http_info(x_path_expression, input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_remove_with_x_path_with_http_info(self, x_path_expression, input_file, **kwargs):  # noqa: E501
          """Remove, delete XML nodes and items matching XPath expression  # noqa: E501
  
          Return the reuslts of editing an XML document by removing all of the nodes that match an input XPath expression  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_remove_with_x_path_with_http_info(x_path_expression, input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str x_path_expression: Valid XML XPath query expression (required)
          :param file input_file: Input file to perform the operation on. (required)
          :return: XmlRemoveWithXPathResult
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['x_path_expression', 'input_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_remove_with_x_path" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'x_path_expression' is set
          if ('x_path_expression' not in params or
                  params['x_path_expression'] is None):
              raise ValueError("Missing the required parameter `x_path_expression` when calling `convert_data_xml_remove_with_x_path`")  # noqa: E501
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_remove_with_x_path`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
          if 'x_path_expression' in params:
              header_params['XPathExpression'] = params['x_path_expression']  # noqa: E501
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json', 'text/json', 'application/xml', 'text/xml'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/edit/xpath/remove', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='XmlRemoveWithXPathResult',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_to_json(self, input_file, **kwargs):  # noqa: E501
          """Convert XML to JSON conversion  # noqa: E501
  
          Convert an XML string or file into JSON  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_to_json(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_to_json_with_http_info(input_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_to_json_with_http_info(self, input_file, **kwargs):  # noqa: E501
          """Convert XML to JSON conversion  # noqa: E501
  
          Convert an XML string or file into JSON  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_to_json_with_http_info(input_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input file to perform the operation on. (required)
          :return: object
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_to_json" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_to_json`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json'])  # noqa: E501
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
              ['multipart/form-data'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/to/json', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='object',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  
      def convert_data_xml_transform_with_xslt_to_xml(self, input_file, transform_file, **kwargs):  # noqa: E501
          """Transform XML document file with XSLT into a new XML document  # noqa: E501
  
          Convert an XML string or file into JSON  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_transform_with_xslt_to_xml(input_file, transform_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param file transform_file: Input XSLT file to use to transform the input XML file. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('async_req'):
              return self.convert_data_xml_transform_with_xslt_to_xml_with_http_info(input_file, transform_file, **kwargs)  # noqa: E501
          else:
              (data) = self.convert_data_xml_transform_with_xslt_to_xml_with_http_info(input_file, transform_file, **kwargs)  # noqa: E501
              return data
  
      def convert_data_xml_transform_with_xslt_to_xml_with_http_info(self, input_file, transform_file, **kwargs):  # noqa: E501
          """Transform XML document file with XSLT into a new XML document  # noqa: E501
  
          Convert an XML string or file into JSON  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.convert_data_xml_transform_with_xslt_to_xml_with_http_info(input_file, transform_file, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param file input_file: Input XML file to perform the operation on. (required)
          :param file transform_file: Input XSLT file to use to transform the input XML file. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['input_file', 'transform_file']  # noqa: E501
          all_params.append('async_req')
          all_params.append('_return_http_data_only')
          all_params.append('_preload_content')
          all_params.append('_request_timeout')
  
          params = locals()
          for key, val in six.iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method convert_data_xml_transform_with_xslt_to_xml" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'input_file' is set
          if ('input_file' not in params or
                  params['input_file'] is None):
              raise ValueError("Missing the required parameter `input_file` when calling `convert_data_xml_transform_with_xslt_to_xml`")  # noqa: E501
          # verify the required parameter 'transform_file' is set
          if ('transform_file' not in params or
                  params['transform_file'] is None):
              raise ValueError("Missing the required parameter `transform_file` when calling `convert_data_xml_transform_with_xslt_to_xml`")  # noqa: E501
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
          if 'input_file' in params:
              local_var_files['inputFile'] = params['input_file']  # noqa: E501
          if 'transform_file' in params:
              local_var_files['transformFile'] = params['transform_file']  # noqa: E501
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/xml'])  # noqa: E501
  
          # Authentication setting
          auth_settings = ['Apikey']  # noqa: E501
  
          return self.api_client.call_api(
              '/convert/xml/transform/xslt/to/xml', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',  # noqa: E501
              auth_settings=auth_settings,
              async_req=params.get('async_req'),
              _return_http_data_only=params.get('_return_http_data_only'),
              _preload_content=params.get('_preload_content', True),
              _request_timeout=params.get('_request_timeout'),
              collection_formats=collection_formats)
  