text: # coding: utf-8
  
  from __future__ import absolute_import
  
  import six
  
  from wallee.api_client import ApiClient
  
  class SubscriptionServiceApi:
  
      def __init__(self, configuration):
          self.api_client = ApiClient(configuration=configuration)
  
      def apply_changes(self, space_id, request, **kwargs):
          """apply changes
  
          This operation allows to apply changes on a subscription.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.apply_changes(space_id, request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param SubscriptionChangeRequest request:  (required)
          :return: SubscriptionVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.apply_changes_with_http_info(space_id, request, **kwargs)
          else:
              (data) = self.apply_changes_with_http_info(space_id, request, **kwargs)
              return data
  
      def apply_changes_with_http_info(self, space_id, request, **kwargs):
          """apply changes
  
          This operation allows to apply changes on a subscription.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.apply_changes_with_http_info(space_id, request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param SubscriptionChangeRequest request:  (required)
          :return: SubscriptionVersion
                   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 apply_changes" % 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 `apply_changes`")
          # 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 `apply_changes`")
  
          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'])
  
          # 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(
              '/subscription/applyChanges', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SubscriptionVersion',
              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(
              '/subscription/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, create_request, **kwargs):
          """Create
  
          The create operation creates a new subscription and a corresponding subscription version.
          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, create_request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param SubscriptionCreateRequest create_request:  (required)
          :return: SubscriptionVersion
                   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, create_request, **kwargs)
          else:
              (data) = self.create_with_http_info(space_id, create_request, **kwargs)
              return data
  
      def create_with_http_info(self, space_id, create_request, **kwargs):
          """Create
  
          The create operation creates a new subscription and a corresponding subscription version.
          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, create_request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param SubscriptionCreateRequest create_request:  (required)
          :return: SubscriptionVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'create_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 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 'create_request' is set
          if ('create_request' not in params or
                  params['create_request'] is None):
              raise ValueError("Missing the required parameter `create_request` 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 'create_request' in params:
              body_params = params['create_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(
              '/subscription/create', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SubscriptionVersion',
              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 initialize(self, space_id, subscription_id, **kwargs):
          """initialize
  
          The initialize operation initializes a subscription. This method uses charge flows to carry out the transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.initialize(space_id, subscription_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The provided subscription id will be used to lookup the subscription which should be initialized. (required)
          :return: SubscriptionCharge
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.initialize_with_http_info(space_id, subscription_id, **kwargs)
          else:
              (data) = self.initialize_with_http_info(space_id, subscription_id, **kwargs)
              return data
  
      def initialize_with_http_info(self, space_id, subscription_id, **kwargs):
          """initialize
  
          The initialize operation initializes a subscription. This method uses charge flows to carry out the transaction.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.initialize_with_http_info(space_id, subscription_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The provided subscription id will be used to lookup the subscription which should be initialized. (required)
          :return: SubscriptionCharge
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'subscription_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 initialize" % 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 `initialize`")
          # verify the required parameter 'subscription_id' is set
          if ('subscription_id' not in params or
                  params['subscription_id'] is None):
              raise ValueError("Missing the required parameter `subscription_id` when calling `initialize`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'subscription_id' in params:
              query_params.append(('subscriptionId', params['subscription_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(
              '/subscription/initialize', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SubscriptionCharge',
              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 initialize_subscriber_present(self, space_id, subscription_id, **kwargs):
          """initializeSubscriberPresent
  
          The initialize operation initializes a subscription when the subscriber is present. The method will initialize a transaction which has to be completed by using the transaction service.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.initialize_subscriber_present(space_id, subscription_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id:  (required)
          :param str success_url: The subscriber will be redirected to the success URL when the transaction is successful.
          :param str failed_url: The subscriber will be redirected to the fail URL when the transaction fails.
          :return: SubscriptionCharge
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.initialize_subscriber_present_with_http_info(space_id, subscription_id, **kwargs)
          else:
              (data) = self.initialize_subscriber_present_with_http_info(space_id, subscription_id, **kwargs)
              return data
  
      def initialize_subscriber_present_with_http_info(self, space_id, subscription_id, **kwargs):
          """initializeSubscriberPresent
  
          The initialize operation initializes a subscription when the subscriber is present. The method will initialize a transaction which has to be completed by using the transaction service.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.initialize_subscriber_present_with_http_info(space_id, subscription_id, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id:  (required)
          :param str success_url: The subscriber will be redirected to the success URL when the transaction is successful.
          :param str failed_url: The subscriber will be redirected to the fail URL when the transaction fails.
          :return: SubscriptionCharge
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'subscription_id', 'success_url', 'failed_url']
          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 initialize_subscriber_present" % 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 `initialize_subscriber_present`")
          # verify the required parameter 'subscription_id' is set
          if ('subscription_id' not in params or
                  params['subscription_id'] is None):
              raise ValueError("Missing the required parameter `subscription_id` when calling `initialize_subscriber_present`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'subscription_id' in params:
              query_params.append(('subscriptionId', params['subscription_id']))
          if 'success_url' in params:
              query_params.append(('successUrl', params['success_url']))
          if 'failed_url' in params:
              query_params.append(('failedUrl', params['failed_url']))
  
          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(
              '/subscription/initializeSubscriberPresent', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SubscriptionCharge',
              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 subscription which should be returned. (required)
          :return: Subscription
                   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 subscription which should be returned. (required)
          :return: Subscription
                   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(
              '/subscription/read', 'GET',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Subscription',
              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 subscriptions which are returned by the search. (required)
          :return: list[Subscription]
                   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 subscriptions which are returned by the search. (required)
          :return: list[Subscription]
                   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(
              '/subscription/search', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[Subscription]',
              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_subscription_invoices(self, space_id, subscription_id, query, **kwargs):
          """Search Subscription Invoices
  
          This operation allows to search for subscription invoices.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_subscription_invoices(space_id, subscription_id, query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The id of the subscription for which the invoices should be searched for. (required)
          :param EntityQuery query: The query restricts the invoices which are returned by the search. (required)
          :return: list[TransactionInvoice]
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.search_subscription_invoices_with_http_info(space_id, subscription_id, query, **kwargs)
          else:
              (data) = self.search_subscription_invoices_with_http_info(space_id, subscription_id, query, **kwargs)
              return data
  
      def search_subscription_invoices_with_http_info(self, space_id, subscription_id, query, **kwargs):
          """Search Subscription Invoices
  
          This operation allows to search for subscription invoices.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.search_subscription_invoices_with_http_info(space_id, subscription_id, query, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The id of the subscription for which the invoices should be searched for. (required)
          :param EntityQuery query: The query restricts the invoices which are returned by the search. (required)
          :return: list[TransactionInvoice]
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'subscription_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_subscription_invoices" % 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_subscription_invoices`")
          # verify the required parameter 'subscription_id' is set
          if ('subscription_id' not in params or
                  params['subscription_id'] is None):
              raise ValueError("Missing the required parameter `subscription_id` when calling `search_subscription_invoices`")
          # 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_subscription_invoices`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'subscription_id' in params:
              query_params.append(('subscriptionId', params['subscription_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(
              '/subscription/searchSubscriptionInvoices', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='list[TransactionInvoice]',
              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 terminate(self, space_id, subscription_id, respect_termination_period, **kwargs):
          """terminate
  
          This operation allows to terminate a subscription.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.terminate(space_id, subscription_id, respect_termination_period, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The subscription id identifies the subscription which should be terminated. (required)
          :param bool respect_termination_period: The respect termination period controls whether the termination period configured on the product version should be respected or if the operation should take effect immediately. (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.terminate_with_http_info(space_id, subscription_id, respect_termination_period, **kwargs)
          else:
              (data) = self.terminate_with_http_info(space_id, subscription_id, respect_termination_period, **kwargs)
              return data
  
      def terminate_with_http_info(self, space_id, subscription_id, respect_termination_period, **kwargs):
          """terminate
  
          This operation allows to terminate a subscription.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.terminate_with_http_info(space_id, subscription_id, respect_termination_period, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The subscription id identifies the subscription which should be terminated. (required)
          :param bool respect_termination_period: The respect termination period controls whether the termination period configured on the product version should be respected or if the operation should take effect immediately. (required)
          :return: None
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'subscription_id', 'respect_termination_period']
          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 terminate" % 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 `terminate`")
          # verify the required parameter 'subscription_id' is set
          if ('subscription_id' not in params or
                  params['subscription_id'] is None):
              raise ValueError("Missing the required parameter `subscription_id` when calling `terminate`")
          # verify the required parameter 'respect_termination_period' is set
          if ('respect_termination_period' not in params or
                  params['respect_termination_period'] is None):
              raise ValueError("Missing the required parameter `respect_termination_period` when calling `terminate`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'subscription_id' in params:
              query_params.append(('subscriptionId', params['subscription_id']))
          if 'respect_termination_period' in params:
              query_params.append(('respectTerminationPeriod', params['respect_termination_period']))
  
          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(
              '/subscription/terminate', '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 update(self, space_id, subscription_id, request, **kwargs):
          """update
  
          This operation allows to update the subscription.
          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, subscription_id, request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id:  (required)
          :param SubscriptionUpdateRequest request:  (required)
          :return: Subscription
                   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, subscription_id, request, **kwargs)
          else:
              (data) = self.update_with_http_info(space_id, subscription_id, request, **kwargs)
              return data
  
      def update_with_http_info(self, space_id, subscription_id, request, **kwargs):
          """update
  
          This operation allows to update the subscription.
          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, subscription_id, request, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id:  (required)
          :param SubscriptionUpdateRequest request:  (required)
          :return: Subscription
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'subscription_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 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 'subscription_id' is set
          if ('subscription_id' not in params or
                  params['subscription_id'] is None):
              raise ValueError("Missing the required parameter `subscription_id` when calling `update`")
          # 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 `update`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'subscription_id' in params:
              query_params.append(('subscriptionId', params['subscription_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'])
  
          # 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(
              '/subscription/update', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='Subscription',
              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_product_version(self, space_id, subscription_id, respect_termination_period, **kwargs):
          """update product version
  
          The update product version operation updates the product version of the subscription to the latest active product version.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_product_version(space_id, subscription_id, respect_termination_period, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The subscription id identifies the subscription which should be updated to the latest version. (required)
          :param bool respect_termination_period: The subscription version may be retired. The respect termination period controls whether the termination period configured on the product version should be respected or if the operation should take effect immediately. (required)
          :return: SubscriptionVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
  
  
          if kwargs.get('async_req'):
              return self.update_product_version_with_http_info(space_id, subscription_id, respect_termination_period, **kwargs)
          else:
              (data) = self.update_product_version_with_http_info(space_id, subscription_id, respect_termination_period, **kwargs)
              return data
  
      def update_product_version_with_http_info(self, space_id, subscription_id, respect_termination_period, **kwargs):
          """update product version
  
          The update product version operation updates the product version of the subscription to the latest active product version.
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
          >>> thread = api.update_product_version_with_http_info(space_id, subscription_id, respect_termination_period, async_req=True)
          >>> result = thread.get()
  
          :param async_req bool
          :param int space_id:  (required)
          :param int subscription_id: The subscription id identifies the subscription which should be updated to the latest version. (required)
          :param bool respect_termination_period: The subscription version may be retired. The respect termination period controls whether the termination period configured on the product version should be respected or if the operation should take effect immediately. (required)
          :return: SubscriptionVersion
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['space_id', 'subscription_id', 'respect_termination_period']
          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_product_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 `update_product_version`")
          # verify the required parameter 'subscription_id' is set
          if ('subscription_id' not in params or
                  params['subscription_id'] is None):
              raise ValueError("Missing the required parameter `subscription_id` when calling `update_product_version`")
          # verify the required parameter 'respect_termination_period' is set
          if ('respect_termination_period' not in params or
                  params['respect_termination_period'] is None):
              raise ValueError("Missing the required parameter `respect_termination_period` when calling `update_product_version`")
  
          collection_formats = {}
  
          path_params = {}
  
          query_params = []
          if 'space_id' in params:
              query_params.append(('spaceId', params['space_id']))
          if 'subscription_id' in params:
              query_params.append(('subscriptionId', params['subscription_id']))
          if 'respect_termination_period' in params:
              query_params.append(('respectTerminationPeriod', params['respect_termination_period']))
  
          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(
              '/subscription/updateProductVersion', 'POST',
              path_params,
              query_params,
              header_params,
              body=body_params,
              post_params=form_params,
              files=local_var_files,
              response_type='SubscriptionVersion',
              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)
  