text: # coding: utf-8
  
  from __future__ import absolute_import
  
  import six
  
  from wallee.api_client import ApiClient
  
  class TransactionServiceApi:
  
      def __init__(self, configuration):
          self.api_client = ApiClient(configuration=configuration)
  
      def confirm(self, space_id, transaction_model, **kwargs):
          """Confirm
  
          The confirm operation marks the transaction as confirmed. Once the transaction is confirmed no more changes can be applied.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.confirm(space_id, transaction_model, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionPending transaction_model: The transaction JSON object to update and confirm. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.confirm_with_http_info(space_id, transaction_model, **kwargs)
          else:
              (data) = self.confirm_with_http_info(space_id, transaction_model, **kwargs)
              return data
  
      def confirm_with_http_info(self, space_id, transaction_model, **kwargs):
          """Confirm
  
          The confirm operation marks the transaction as confirmed. Once the transaction is confirmed no more changes can be applied.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.confirm_with_http_info(space_id, transaction_model, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionPending transaction_model: The transaction JSON object to update and confirm. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'transaction_model']
          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 confirm" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `confirm`")
          # verify the required parameter 'transaction_model' is set
          if ('transaction_model' not in params or
                  params['transaction_model'] is None):
              raise ValueError("Missing the required parameter `transaction_model` when calling `confirm`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'transaction_model' in params:
              body_params = params['transaction_model']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/confirm', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Transaction',
              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 count(self, space_id, **kwargs):
          """Count
  
          Counts the number of items in the database as restricted by the given filter.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.count(space_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count.
          :return: int
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.count_with_http_info(space_id, **kwargs)
          else:
              (data) = self.count_with_http_info(space_id, **kwargs)
              return data
  
      def count_with_http_info(self, space_id, **kwargs):
          """Count
  
          Counts the number of items in the database as restricted by the given filter.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.count_with_http_info(space_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param EntityQueryFilter filter: The filter which restricts the entities which are used to calculate the count.
          :return: int
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'filter']
          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 count" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `count`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'filter' in params:
              body_params = params['filter']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/count', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='int',
              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 create(self, space_id, transaction, **kwargs):
          """Create
  
          Creates the entity with the given properties.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.create(space_id, transaction, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionCreate transaction: The transaction object which should be created. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.create_with_http_info(space_id, transaction, **kwargs)
          else:
              (data) = self.create_with_http_info(space_id, transaction, **kwargs)
              return data
  
      def create_with_http_info(self, space_id, transaction, **kwargs):
          """Create
  
          Creates the entity with the given properties.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.create_with_http_info(space_id, transaction, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionCreate transaction: The transaction object which should be created. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'transaction']
          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 create" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `create`")
          # verify the required parameter 'transaction' is set
          if ('transaction' not in params or
                  params['transaction'] is None):
              raise ValueError("Missing the required parameter `transaction` when calling `create`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'transaction' in params:
              body_params = params['transaction']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/create', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Transaction',
              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 create_transaction_credentials(self, space_id, id, **kwargs):
          """Create Transaction Credentials
  
          This operation allows to create transaction credentials to delegate temporarily the access to the web service API for this particular transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.create_transaction_credentials(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be returned. (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.create_transaction_credentials_with_http_info(space_id, id, **kwargs)
          else:
              (data) = self.create_transaction_credentials_with_http_info(space_id, id, **kwargs)
              return data
  
      def create_transaction_credentials_with_http_info(self, space_id, id, **kwargs):
          """Create Transaction Credentials
  
          This operation allows to create transaction credentials to delegate temporarily the access to the web service API for this particular transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.create_transaction_credentials_with_http_info(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be returned. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id']
          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 create_transaction_credentials" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `create_transaction_credentials`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `create_transaction_credentials`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/createTransactionCredentials', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',
              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 delete_one_click_token_with_credentials(self, credentials, token_id, **kwargs):
          """Delete One-Click Token with Credentials
  
          This operation removes the given token.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_one_click_token_with_credentials(credentials, token_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :param int token_id: The token ID will be used to find the token which should be removed. (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.delete_one_click_token_with_credentials_with_http_info(credentials, token_id, **kwargs)
          else:
              (data) = self.delete_one_click_token_with_credentials_with_http_info(credentials, token_id, **kwargs)
              return data
  
      def delete_one_click_token_with_credentials_with_http_info(self, credentials, token_id, **kwargs):
          """Delete One-Click Token with Credentials
  
          This operation removes the given token.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.delete_one_click_token_with_credentials_with_http_info(credentials, token_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :param int token_id: The token ID will be used to find the token which should be removed. (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['credentials', 'token_id']
          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 delete_one_click_token_with_credentials" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'credentials' is set
          if ('credentials' not in params or
                  params['credentials'] is None):
              raise ValueError("Missing the required parameter `credentials` when calling `delete_one_click_token_with_credentials`")
          # verify the required parameter 'token_id' is set
          if ('token_id' not in params or
                  params['token_id'] is None):
              raise ValueError("Missing the required parameter `token_id` when calling `delete_one_click_token_with_credentials`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'credentials' in params:
              query_params.append(('credentials', params['credentials']))
          if 'token_id' in params:
              query_params.append(('tokenId', params['token_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/deleteOneClickTokenWithCredentials', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type=None,
              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 export(self, space_id, request, **kwargs):
          """Export
  
          Exports the transactions into a CSV file. The file will contain the properties defined in the request.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.export(space_id, request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param EntityExportRequest request: The request controls the entries which are exported. (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.export_with_http_info(space_id, request, **kwargs)
          else:
              (data) = self.export_with_http_info(space_id, request, **kwargs)
              return data
  
      def export_with_http_info(self, space_id, request, **kwargs):
          """Export
  
          Exports the transactions into a CSV file. The file will contain the properties defined in the request.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.export_with_http_info(space_id, request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param EntityExportRequest request: The request controls the entries which are exported. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'request']
          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 export" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `export`")
          # verify the required parameter 'request' is set
          if ('request' not in params or
                  params['request'] is None):
              raise ValueError("Missing the required parameter `request` when calling `export`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'request' in params:
              body_params = params['request']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8', 'text/csv'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/export', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',
              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 fetch_one_click_tokens_with_credentials(self, credentials, **kwargs):
          """Fetch One Click Tokens with Credentials
  
          This operation returns the token version objects which references the tokens usable as one-click payment tokens for the provided transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.fetch_one_click_tokens_with_credentials(credentials, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :return: list[TokenVersion]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.fetch_one_click_tokens_with_credentials_with_http_info(credentials, **kwargs)
          else:
              (data) = self.fetch_one_click_tokens_with_credentials_with_http_info(credentials, **kwargs)
              return data
  
      def fetch_one_click_tokens_with_credentials_with_http_info(self, credentials, **kwargs):
          """Fetch One Click Tokens with Credentials
  
          This operation returns the token version objects which references the tokens usable as one-click payment tokens for the provided transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.fetch_one_click_tokens_with_credentials_with_http_info(credentials, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :return: list[TokenVersion]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['credentials']
          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 fetch_one_click_tokens_with_credentials" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'credentials' is set
          if ('credentials' not in params or
                  params['credentials'] is None):
              raise ValueError("Missing the required parameter `credentials` when calling `fetch_one_click_tokens_with_credentials`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'credentials' in params:
              query_params.append(('credentials', params['credentials']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/fetchOneClickTokensWithCredentials', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[TokenVersion]',
              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 fetch_payment_methods(self, space_id, id, integration_mode, **kwargs):
          """Fetch Possible Payment Methods
  
          This operation allows to get the payment method configurations which can be used with the provided transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.fetch_payment_methods(space_id, id, integration_mode, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be returned. (required)
          :param str integration_mode: The integration mode defines the type of integration that is applied on the transaction. (required)
          :return: list[PaymentMethodConfiguration]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.fetch_payment_methods_with_http_info(space_id, id, integration_mode, **kwargs)
          else:
              (data) = self.fetch_payment_methods_with_http_info(space_id, id, integration_mode, **kwargs)
              return data
  
      def fetch_payment_methods_with_http_info(self, space_id, id, integration_mode, **kwargs):
          """Fetch Possible Payment Methods
  
          This operation allows to get the payment method configurations which can be used with the provided transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.fetch_payment_methods_with_http_info(space_id, id, integration_mode, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be returned. (required)
          :param str integration_mode: The integration mode defines the type of integration that is applied on the transaction. (required)
          :return: list[PaymentMethodConfiguration]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id', 'integration_mode']
          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 fetch_payment_methods" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `fetch_payment_methods`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `fetch_payment_methods`")
          # verify the required parameter 'integration_mode' is set
          if ('integration_mode' not in params or
                  params['integration_mode'] is None):
              raise ValueError("Missing the required parameter `integration_mode` when calling `fetch_payment_methods`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
          if 'integration_mode' in params:
              query_params.append(('integrationMode', params['integration_mode']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/fetch-payment-methods', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[PaymentMethodConfiguration]',
              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 fetch_payment_methods_with_credentials(self, credentials, integration_mode, **kwargs):
          """Fetch Possible Payment Methods with Credentials
  
          This operation allows to get the payment method configurations which can be used with the provided transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.fetch_payment_methods_with_credentials(credentials, integration_mode, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :param str integration_mode: The integration mode defines the type of integration that is applied on the transaction. (required)
          :return: list[PaymentMethodConfiguration]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.fetch_payment_methods_with_credentials_with_http_info(credentials, integration_mode, **kwargs)
          else:
              (data) = self.fetch_payment_methods_with_credentials_with_http_info(credentials, integration_mode, **kwargs)
              return data
  
      def fetch_payment_methods_with_credentials_with_http_info(self, credentials, integration_mode, **kwargs):
          """Fetch Possible Payment Methods with Credentials
  
          This operation allows to get the payment method configurations which can be used with the provided transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.fetch_payment_methods_with_credentials_with_http_info(credentials, integration_mode, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :param str integration_mode: The integration mode defines the type of integration that is applied on the transaction. (required)
          :return: list[PaymentMethodConfiguration]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['credentials', 'integration_mode']
          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 fetch_payment_methods_with_credentials" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'credentials' is set
          if ('credentials' not in params or
                  params['credentials'] is None):
              raise ValueError("Missing the required parameter `credentials` when calling `fetch_payment_methods_with_credentials`")
          # verify the required parameter 'integration_mode' is set
          if ('integration_mode' not in params or
                  params['integration_mode'] is None):
              raise ValueError("Missing the required parameter `integration_mode` when calling `fetch_payment_methods_with_credentials`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'credentials' in params:
              query_params.append(('credentials', params['credentials']))
          if 'integration_mode' in params:
              query_params.append(('integrationMode', params['integration_mode']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/fetch-payment-methods-with-credentials', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[PaymentMethodConfiguration]',
              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 get_invoice_document(self, space_id, id, **kwargs):
          """getInvoiceDocument
  
          Returns the PDF document for the transaction invoice with given id.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_invoice_document(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction to get the invoice document for. (required)
          :return: RenderedDocument
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.get_invoice_document_with_http_info(space_id, id, **kwargs)
          else:
              (data) = self.get_invoice_document_with_http_info(space_id, id, **kwargs)
              return data
  
      def get_invoice_document_with_http_info(self, space_id, id, **kwargs):
          """getInvoiceDocument
  
          Returns the PDF document for the transaction invoice with given id.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_invoice_document_with_http_info(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction to get the invoice document for. (required)
          :return: RenderedDocument
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id']
          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 get_invoice_document" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `get_invoice_document`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `get_invoice_document`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['*/*'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/getInvoiceDocument', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='RenderedDocument',
              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 get_latest_transaction_line_item_version(self, space_id, id, **kwargs):
          """getLatestTransactionLineItemVersion
  
          
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_latest_transaction_line_item_version(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction to get the latest line item version for. (required)
          :return: TransactionLineItemVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.get_latest_transaction_line_item_version_with_http_info(space_id, id, **kwargs)
          else:
              (data) = self.get_latest_transaction_line_item_version_with_http_info(space_id, id, **kwargs)
              return data
  
      def get_latest_transaction_line_item_version_with_http_info(self, space_id, id, **kwargs):
          """getLatestTransactionLineItemVersion
  
          
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_latest_transaction_line_item_version_with_http_info(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction to get the latest line item version for. (required)
          :return: TransactionLineItemVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id']
          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 get_latest_transaction_line_item_version" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `get_latest_transaction_line_item_version`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `get_latest_transaction_line_item_version`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/getLatestTransactionLineItemVersion', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='TransactionLineItemVersion',
              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 get_packing_slip(self, space_id, id, **kwargs):
          """getPackingSlip
  
          Returns the packing slip for the transaction with given id.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_packing_slip(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction to get the packing slip for. (required)
          :return: RenderedDocument
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.get_packing_slip_with_http_info(space_id, id, **kwargs)
          else:
              (data) = self.get_packing_slip_with_http_info(space_id, id, **kwargs)
              return data
  
      def get_packing_slip_with_http_info(self, space_id, id, **kwargs):
          """getPackingSlip
  
          Returns the packing slip for the transaction with given id.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.get_packing_slip_with_http_info(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction to get the packing slip for. (required)
          :return: RenderedDocument
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id']
          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 get_packing_slip" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `get_packing_slip`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `get_packing_slip`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['*/*'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/getPackingSlip', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='RenderedDocument',
              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 process_one_click_token_and_redirect_with_credentials(self, credentials, token_id, **kwargs):
          """Process One-Click Token with Credentials
  
          This operation assigns the given token to the transaction and process it. This method will return an URL where the customer has to be redirect to complete the transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.process_one_click_token_and_redirect_with_credentials(credentials, token_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :param int token_id: The token ID is used to load the corresponding token and to process the transaction with it. (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.process_one_click_token_and_redirect_with_credentials_with_http_info(credentials, token_id, **kwargs)
          else:
              (data) = self.process_one_click_token_and_redirect_with_credentials_with_http_info(credentials, token_id, **kwargs)
              return data
  
      def process_one_click_token_and_redirect_with_credentials_with_http_info(self, credentials, token_id, **kwargs):
          """Process One-Click Token with Credentials
  
          This operation assigns the given token to the transaction and process it. This method will return an URL where the customer has to be redirect to complete the transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.process_one_click_token_and_redirect_with_credentials_with_http_info(credentials, token_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :param int token_id: The token ID is used to load the corresponding token and to process the transaction with it. (required)
          :return: str
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['credentials', 'token_id']
          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 process_one_click_token_and_redirect_with_credentials" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'credentials' is set
          if ('credentials' not in params or
                  params['credentials'] is None):
              raise ValueError("Missing the required parameter `credentials` when calling `process_one_click_token_and_redirect_with_credentials`")
          # verify the required parameter 'token_id' is set
          if ('token_id' not in params or
                  params['token_id'] is None):
              raise ValueError("Missing the required parameter `token_id` when calling `process_one_click_token_and_redirect_with_credentials`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'credentials' in params:
              query_params.append(('credentials', params['credentials']))
          if 'token_id' in params:
              query_params.append(('tokenId', params['token_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/processOneClickTokenAndRedirectWithCredentials', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='str',
              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 process_without_user_interaction(self, space_id, id, **kwargs):
          """Process Without User Interaction
  
          This operation processes the transaction without requiring that the customer is present. Means this operation applies strategies to process the transaction without a direct interaction with the buyer. This operation is suitable for recurring transactions.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.process_without_user_interaction(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be processed. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.process_without_user_interaction_with_http_info(space_id, id, **kwargs)
          else:
              (data) = self.process_without_user_interaction_with_http_info(space_id, id, **kwargs)
              return data
  
      def process_without_user_interaction_with_http_info(self, space_id, id, **kwargs):
          """Process Without User Interaction
  
          This operation processes the transaction without requiring that the customer is present. Means this operation applies strategies to process the transaction without a direct interaction with the buyer. This operation is suitable for recurring transactions.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.process_without_user_interaction_with_http_info(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be processed. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id']
          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 process_without_user_interaction" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `process_without_user_interaction`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `process_without_user_interaction`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/processWithoutUserInteraction', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Transaction',
              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 read(self, space_id, id, **kwargs):
          """Read
  
          Reads the entity with the given 'id' and returns it.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.read(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be returned. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.read_with_http_info(space_id, id, **kwargs)
          else:
              (data) = self.read_with_http_info(space_id, id, **kwargs)
              return data
  
      def read_with_http_info(self, space_id, id, **kwargs):
          """Read
  
          Reads the entity with the given 'id' and returns it.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.read_with_http_info(space_id, id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int id: The id of the transaction which should be returned. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'id']
          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 read" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `read`")
          # verify the required parameter 'id' is set
          if ('id' not in params or
                  params['id'] is None):
              raise ValueError("Missing the required parameter `id` when calling `read`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'id' in params:
              query_params.append(('id', params['id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['*/*'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/read', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Transaction',
              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 read_with_credentials(self, credentials, **kwargs):
          """Read With Credentials
  
          Reads the transaction with the given 'id' and returns it. This method uses the credentials to authenticate and identify the transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.read_with_credentials(credentials, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.read_with_credentials_with_http_info(credentials, **kwargs)
          else:
              (data) = self.read_with_credentials_with_http_info(credentials, **kwargs)
              return data
  
      def read_with_credentials_with_http_info(self, credentials, **kwargs):
          """Read With Credentials
  
          Reads the transaction with the given 'id' and returns it. This method uses the credentials to authenticate and identify the transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.read_with_credentials_with_http_info(credentials, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param str credentials: The credentials identifies the transaction and contains the security details which grants the access this operation. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['credentials']
          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 read_with_credentials" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'credentials' is set
          if ('credentials' not in params or
                  params['credentials'] is None):
              raise ValueError("Missing the required parameter `credentials` when calling `read_with_credentials`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'credentials' in params:
              query_params.append(('credentials', params['credentials']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['*/*'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/readWithCredentials', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Transaction',
              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 search(self, space_id, query, **kwargs):
          """Search
  
          Searches for the entities as specified by the given query.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search(space_id, query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param EntityQuery query: The query restricts the transactions which are returned by the search. (required)
          :return: list[Transaction]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.search_with_http_info(space_id, query, **kwargs)
          else:
              (data) = self.search_with_http_info(space_id, query, **kwargs)
              return data
  
      def search_with_http_info(self, space_id, query, **kwargs):
          """Search
  
          Searches for the entities as specified by the given query.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_with_http_info(space_id, query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param EntityQuery query: The query restricts the transactions which are returned by the search. (required)
          :return: list[Transaction]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'query']
          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 search" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `search`")
          # verify the required parameter 'query' is set
          if ('query' not in params or
                  params['query'] is None):
              raise ValueError("Missing the required parameter `query` when calling `search`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'query' in params:
              body_params = params['query']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/search', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[Transaction]',
              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 update(self, space_id, entity, **kwargs):
          """Update
  
          This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update(space_id, entity, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionPending entity: The transaction object with the properties which should be updated. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.update_with_http_info(space_id, entity, **kwargs)
          else:
              (data) = self.update_with_http_info(space_id, entity, **kwargs)
              return data
  
      def update_with_http_info(self, space_id, entity, **kwargs):
          """Update
  
          This updates the entity with the given properties. Only those properties which should be updated can be provided. The 'id' and 'version' are required to identify the entity.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_with_http_info(space_id, entity, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionPending entity: The transaction object with the properties which should be updated. (required)
          :return: Transaction
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'entity']
          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 update" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `update`")
          # verify the required parameter 'entity' is set
          if ('entity' not in params or
                  params['entity'] is None):
              raise ValueError("Missing the required parameter `entity` when calling `update`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'entity' in params:
              body_params = params['entity']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/update', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Transaction',
              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 update_transaction_line_items(self, space_id, update_request, **kwargs):
          """updateTransactionLineItems
  
          
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_transaction_line_items(space_id, update_request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionLineItemUpdateRequest update_request:  (required)
          :return: TransactionLineItemVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.update_transaction_line_items_with_http_info(space_id, update_request, **kwargs)
          else:
              (data) = self.update_transaction_line_items_with_http_info(space_id, update_request, **kwargs)
              return data
  
      def update_transaction_line_items_with_http_info(self, space_id, update_request, **kwargs):
          """updateTransactionLineItems
  
          
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_transaction_line_items_with_http_info(space_id, update_request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param TransactionLineItemUpdateRequest update_request:  (required)
          :return: TransactionLineItemVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'update_request']
          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 update_transaction_line_items" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'space_id' is set
          if ('space_id' not in params or
                  params['space_id'] is None):
              raise ValueError("Missing the required parameter `space_id` when calling `update_transaction_line_items`")
          # verify the required parameter 'update_request' is set
          if ('update_request' not in params or
                  params['update_request'] is None):
              raise ValueError("Missing the required parameter `update_request` when calling `update_transaction_line_items`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
  
          header_params = {}
  
          form_params = []
          local_var_files = {}
  
          body_params = None
          if 'update_request' in params:
              body_params = params['update_request']
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.select_header_accept(
              ['application/json;charset=utf-8'])
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.select_header_content_type(
              ['application/json;charset=utf-8'])
  
          # Authentication setting
          auth_settings = []
  
          return self.api_client.call_api(
              '/transaction/updateTransactionLineItems', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='TransactionLineItemVersion',
              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)
  