text: # coding: utf-8
  
  """
      iEngage 2.0 API
  
      This API enables Intelligent Engagement for your Business. iEngage is a platform that combines process, augmented intelligence and rewards to help you intelligently engage customers.
  
      OpenAPI spec version: 2.0
      
      Generated by: https://github.com/swagger-api/swagger-codegen.git
  
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
  
          http://www.apache.org/licenses/LICENSE-2.0
  
      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
  """
  
  from __future__ import absolute_import
  
  import sys
  import os
  import re
  
  # python 2 and python 3 compatibility library
  from six import iteritems
  
  from ..configuration import Configuration
  from ..api_client import ApiClient
  
  
  class SocialApi(object):
      """
      NOTE: This class is auto generated by the swagger code generator program.
      Do not edit the class manually.
      Ref: https://github.com/swagger-api/swagger-codegen
      """
  
      def __init__(self, api_client=None):
          config = Configuration()
          if api_client:
              self.api_client = api_client
          else:
              if not config.api_client:
                  config.api_client = ApiClient()
              self.api_client = config.api_client
  
      def add_friend(self, id1, id2, requester_id, client_token, **kwargs):
          """
          Add Friend
          Allows the user to add friend. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.add_friend(id1, id2, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id1: Enter userId/mailId of the person who wants to add a friend (required)
          :param str id2: Enter userId /mailId you want to add in friend list (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.add_friend_with_http_info(id1, id2, requester_id, client_token, **kwargs)
          else:
              (data) = self.add_friend_with_http_info(id1, id2, requester_id, client_token, **kwargs)
              return data
  
      def add_friend_with_http_info(self, id1, id2, requester_id, client_token, **kwargs):
          """
          Add Friend
          Allows the user to add friend. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.add_friend_with_http_info(id1, id2, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id1: Enter userId/mailId of the person who wants to add a friend (required)
          :param str id2: Enter userId /mailId you want to add in friend list (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['id1', 'id2', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method add_friend" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'id1' is set
          if ('id1' not in params) or (params['id1'] is None):
              raise ValueError("Missing the required parameter `id1` when calling `add_friend`")
          # verify the required parameter 'id2' is set
          if ('id2' not in params) or (params['id2'] is None):
              raise ValueError("Missing the required parameter `id2` when calling `add_friend`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `add_friend`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `add_friend`")
  
          resource_path = '/social/friends/add'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
          if 'id1' in params:
              form_params.append(('Id1', params['id1']))
          if 'id2' in params:
              form_params.append(('Id2', params['id2']))
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/x-www-form-urlencoded'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'POST',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='bool',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def confirm_friend_request(self, user_id, status, requester_id, client_token, **kwargs):
          """
          confirm/ignore friend request
          Allows the user to confirm/ignore friend request. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.confirm_friend_request(user_id, status, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: userId of user who sent friend request (required)
          :param int status:   /*  Set Friend Request status      CONFIRM - 1      IGNORE - 2   */  (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.confirm_friend_request_with_http_info(user_id, status, requester_id, client_token, **kwargs)
          else:
              (data) = self.confirm_friend_request_with_http_info(user_id, status, requester_id, client_token, **kwargs)
              return data
  
      def confirm_friend_request_with_http_info(self, user_id, status, requester_id, client_token, **kwargs):
          """
          confirm/ignore friend request
          Allows the user to confirm/ignore friend request. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.confirm_friend_request_with_http_info(user_id, status, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: userId of user who sent friend request (required)
          :param int status:   /*  Set Friend Request status      CONFIRM - 1      IGNORE - 2   */  (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'status', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method confirm_friend_request" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `confirm_friend_request`")
          # verify the required parameter 'status' is set
          if ('status' not in params) or (params['status'] is None):
              raise ValueError("Missing the required parameter `status` when calling `confirm_friend_request`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `confirm_friend_request`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `confirm_friend_request`")
  
          resource_path = '/social/friends/request/action'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
          if 'user_id' in params:
              form_params.append(('userId', params['user_id']))
          if 'status' in params:
              form_params.append(('status', params['status']))
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/x-www-form-urlencoded'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'POST',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='bool',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def follow(self, follower, followee, requester_id, client_token, **kwargs):
          """
          Follow user
          Allows to follow a user. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.follow(follower, followee, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str follower: Enter the userId/mailId of the follower (required)
          :param str followee: Enter the userId/mailId of the user the follower wants to follow (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.follow_with_http_info(follower, followee, requester_id, client_token, **kwargs)
          else:
              (data) = self.follow_with_http_info(follower, followee, requester_id, client_token, **kwargs)
              return data
  
      def follow_with_http_info(self, follower, followee, requester_id, client_token, **kwargs):
          """
          Follow user
          Allows to follow a user. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.follow_with_http_info(follower, followee, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str follower: Enter the userId/mailId of the follower (required)
          :param str followee: Enter the userId/mailId of the user the follower wants to follow (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['follower', 'followee', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method follow" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'follower' is set
          if ('follower' not in params) or (params['follower'] is None):
              raise ValueError("Missing the required parameter `follower` when calling `follow`")
          # verify the required parameter 'followee' is set
          if ('followee' not in params) or (params['followee'] is None):
              raise ValueError("Missing the required parameter `followee` when calling `follow`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `follow`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `follow`")
  
          resource_path = '/social/follow'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
          if 'follower' in params:
              form_params.append(('follower', params['follower']))
          if 'followee' in params:
              form_params.append(('followee', params['followee']))
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/x-www-form-urlencoded'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'POST',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='bool',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def get_user(self, user_id, requester_id, client_token, **kwargs):
          """
          Get user by id 
          Returns the user.
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: User Id (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUser
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_user_with_http_info(user_id, requester_id, client_token, **kwargs)
          else:
              (data) = self.get_user_with_http_info(user_id, requester_id, client_token, **kwargs)
              return data
  
      def get_user_with_http_info(self, user_id, requester_id, client_token, **kwargs):
          """
          Get user by id 
          Returns the user.
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_with_http_info(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: User Id (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUser
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'requester_id', 'client_token', 'fields', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method get_user" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `get_user`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `get_user`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `get_user`")
  
          resource_path = '/social/users/{userId}'.replace('{format}', 'json')
          path_params = {}
          if 'user_id' in params:
              path_params['userId'] = params['user_id']
  
          query_params = {}
          if 'fields' in params:
              query_params['fields'] = params['fields']
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'GET',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='VerveResponseUser',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def get_user_detail(self, user_id, requester_id, client_token, **kwargs):
          """
          Get user details 
          Returns the user details.
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_detail(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: Enter user Id whose details you need (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserDetail
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_user_detail_with_http_info(user_id, requester_id, client_token, **kwargs)
          else:
              (data) = self.get_user_detail_with_http_info(user_id, requester_id, client_token, **kwargs)
              return data
  
      def get_user_detail_with_http_info(self, user_id, requester_id, client_token, **kwargs):
          """
          Get user details 
          Returns the user details.
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_detail_with_http_info(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: Enter user Id whose details you need (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserDetail
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method get_user_detail" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `get_user_detail`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `get_user_detail`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `get_user_detail`")
  
          resource_path = '/social/userDetail'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
          if 'user_id' in params:
              query_params['userId'] = params['user_id']
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'GET',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='VerveResponseUserDetail',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def get_user_followers(self, user_id, requester_id, client_token, **kwargs):
          """
          Get list of followers
          Returns the list of followers
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_followers(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: User Id whose followers wants to get. (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserList
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_user_followers_with_http_info(user_id, requester_id, client_token, **kwargs)
          else:
              (data) = self.get_user_followers_with_http_info(user_id, requester_id, client_token, **kwargs)
              return data
  
      def get_user_followers_with_http_info(self, user_id, requester_id, client_token, **kwargs):
          """
          Get list of followers
          Returns the list of followers
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_followers_with_http_info(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: User Id whose followers wants to get. (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserList
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'requester_id', 'client_token', 'fields', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method get_user_followers" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `get_user_followers`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `get_user_followers`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `get_user_followers`")
  
          resource_path = '/social/followers/{userId}'.replace('{format}', 'json')
          path_params = {}
          if 'user_id' in params:
              path_params['userId'] = params['user_id']
  
          query_params = {}
          if 'fields' in params:
              query_params['fields'] = params['fields']
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'GET',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='VerveResponseUserList',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def get_user_following(self, user_id, requester_id, client_token, **kwargs):
          """
          Get list of users that are being followed
          Returns the list of users that are being followed
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_following(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: User Id whose followed list want to get (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserList
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_user_following_with_http_info(user_id, requester_id, client_token, **kwargs)
          else:
              (data) = self.get_user_following_with_http_info(user_id, requester_id, client_token, **kwargs)
              return data
  
      def get_user_following_with_http_info(self, user_id, requester_id, client_token, **kwargs):
          """
          Get list of users that are being followed
          Returns the list of users that are being followed
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_following_with_http_info(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: User Id whose followed list want to get (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserList
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'requester_id', 'client_token', 'fields', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method get_user_following" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `get_user_following`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `get_user_following`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `get_user_following`")
  
          resource_path = '/social/following/{userId}'.replace('{format}', 'json')
          path_params = {}
          if 'user_id' in params:
              path_params['userId'] = params['user_id']
  
          query_params = {}
          if 'fields' in params:
              query_params['fields'] = params['fields']
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'GET',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='VerveResponseUserList',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def get_user_friends(self, user_id, requester_id, client_token, **kwargs):
          """
          Get list of friends
          Returns the list of friends
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_friends(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: userId (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserList
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.get_user_friends_with_http_info(user_id, requester_id, client_token, **kwargs)
          else:
              (data) = self.get_user_friends_with_http_info(user_id, requester_id, client_token, **kwargs)
              return data
  
      def get_user_friends_with_http_info(self, user_id, requester_id, client_token, **kwargs):
          """
          Get list of friends
          Returns the list of friends
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.get_user_friends_with_http_info(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: userId (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str fields: Filter fields in result list        /*   **A) Default values -**        1)userId       2)firstName       3)lastName       4)profileImage        **A) Available values-**       1)userId       2)firstName       3)lastName       4)emailId       5)profileImage       6)birthDate        */
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseUserList
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'requester_id', 'client_token', 'fields', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method get_user_friends" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `get_user_friends`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `get_user_friends`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `get_user_friends`")
  
          resource_path = '/social/friends{userId}'.replace('{format}', 'json')
          path_params = {}
          if 'user_id' in params:
              path_params['userId'] = params['user_id']
  
          query_params = {}
          if 'fields' in params:
              query_params['fields'] = params['fields']
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'GET',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='VerveResponseUserList',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def remove_friend(self, id1, id2, requester_id, client_token, **kwargs):
          """
          Remove friend 
          Allows the user to remove friend. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.remove_friend(id1, id2, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id1: Enter userId/mailId of the person who wants to remove from friend (required)
          :param str id2: Enter userId /mailId you want to remove in friend list (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.remove_friend_with_http_info(id1, id2, requester_id, client_token, **kwargs)
          else:
              (data) = self.remove_friend_with_http_info(id1, id2, requester_id, client_token, **kwargs)
              return data
  
      def remove_friend_with_http_info(self, id1, id2, requester_id, client_token, **kwargs):
          """
          Remove friend 
          Allows the user to remove friend. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.remove_friend_with_http_info(id1, id2, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str id1: Enter userId/mailId of the person who wants to remove from friend (required)
          :param str id2: Enter userId /mailId you want to remove in friend list (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['id1', 'id2', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method remove_friend" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'id1' is set
          if ('id1' not in params) or (params['id1'] is None):
              raise ValueError("Missing the required parameter `id1` when calling `remove_friend`")
          # verify the required parameter 'id2' is set
          if ('id2' not in params) or (params['id2'] is None):
              raise ValueError("Missing the required parameter `id2` when calling `remove_friend`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `remove_friend`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `remove_friend`")
  
          resource_path = '/social/friends/remove'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
          if 'id1' in params:
              form_params.append(('Id1', params['id1']))
          if 'id2' in params:
              form_params.append(('Id2', params['id2']))
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/x-www-form-urlencoded'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'POST',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='bool',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def request_friend(self, user_id, requester_id, client_token, **kwargs):
          """
          Send friend request
          Allows user to send a friend request. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.request_friend(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: Enter userId /mailId you want to send friend request (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.request_friend_with_http_info(user_id, requester_id, client_token, **kwargs)
          else:
              (data) = self.request_friend_with_http_info(user_id, requester_id, client_token, **kwargs)
              return data
  
      def request_friend_with_http_info(self, user_id, requester_id, client_token, **kwargs):
          """
          Send friend request
          Allows user to send a friend request. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.request_friend_with_http_info(user_id, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param int user_id: Enter userId /mailId you want to send friend request (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['user_id', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method request_friend" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'user_id' is set
          if ('user_id' not in params) or (params['user_id'] is None):
              raise ValueError("Missing the required parameter `user_id` when calling `request_friend`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `request_friend`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `request_friend`")
  
          resource_path = '/social/friends/request'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
          if 'user_id' in params:
              query_params['userId'] = params['user_id']
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/x-www-form-urlencoded'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'POST',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='bool',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def requests_for_me(self, requester_id, client_token, **kwargs):
          """
          Get list of friend requests
          Returns the list of friend requests
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.requests_for_me(requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseRequestForMeList
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.requests_for_me_with_http_info(requester_id, client_token, **kwargs)
          else:
              (data) = self.requests_for_me_with_http_info(requester_id, client_token, **kwargs)
              return data
  
      def requests_for_me_with_http_info(self, requester_id, client_token, **kwargs):
          """
          Get list of friend requests
          Returns the list of friend requests
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.requests_for_me_with_http_info(requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: VerveResponseRequestForMeList
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method requests_for_me" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `requests_for_me`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `requests_for_me`")
  
          resource_path = '/social/friends/request'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/json'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'GET',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='VerveResponseRequestForMeList',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  
      def unfollow(self, unfollower, unfollowee, requester_id, client_token, **kwargs):
          """
          Unfollow user
          Allows to unfollow user. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.unfollow(unfollower, unfollowee, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str unfollower: Enter the userId/mailId of the unfollower (required)
          :param str unfollowee: Enter the userId/mailId of the user the unfollower wants to unfollow (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
          kwargs['_return_http_data_only'] = True
          if kwargs.get('callback'):
              return self.unfollow_with_http_info(unfollower, unfollowee, requester_id, client_token, **kwargs)
          else:
              (data) = self.unfollow_with_http_info(unfollower, unfollowee, requester_id, client_token, **kwargs)
              return data
  
      def unfollow_with_http_info(self, unfollower, unfollowee, requester_id, client_token, **kwargs):
          """
          Unfollow user
          Allows to unfollow user. Returns true if successful
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please define a `callback` function
          to be invoked when receiving the response.
          >>> def callback_function(response):
          >>>     pprint(response)
          >>>
          >>> thread = api.unfollow_with_http_info(unfollower, unfollowee, requester_id, client_token, callback=callback_function)
  
          :param callback function: The callback function
              for asynchronous request. (optional)
          :param str unfollower: Enter the userId/mailId of the unfollower (required)
          :param str unfollowee: Enter the userId/mailId of the user the unfollower wants to unfollow (required)
          :param str requester_id: requesterId can be user id OR email address. (required)
          :param str client_token: Use the Client Token. Please generate it from the Applications section under the Production & Sandbox tabs (required)
          :param str access_token: Unique session token for user. To get access token user will have to authenticate
          :return: bool
                   If the method is called asynchronously,
                   returns the request thread.
          """
  
          all_params = ['unfollower', 'unfollowee', 'requester_id', 'client_token', 'access_token']
          all_params.append('callback')
          all_params.append('_return_http_data_only')
  
          params = locals()
          for key, val in iteritems(params['kwargs']):
              if key not in all_params:
                  raise TypeError(
                      "Got an unexpected keyword argument '%s'"
                      " to method unfollow" % key
                  )
              params[key] = val
          del params['kwargs']
          # verify the required parameter 'unfollower' is set
          if ('unfollower' not in params) or (params['unfollower'] is None):
              raise ValueError("Missing the required parameter `unfollower` when calling `unfollow`")
          # verify the required parameter 'unfollowee' is set
          if ('unfollowee' not in params) or (params['unfollowee'] is None):
              raise ValueError("Missing the required parameter `unfollowee` when calling `unfollow`")
          # verify the required parameter 'requester_id' is set
          if ('requester_id' not in params) or (params['requester_id'] is None):
              raise ValueError("Missing the required parameter `requester_id` when calling `unfollow`")
          # verify the required parameter 'client_token' is set
          if ('client_token' not in params) or (params['client_token'] is None):
              raise ValueError("Missing the required parameter `client_token` when calling `unfollow`")
  
          resource_path = '/social/unfollow'.replace('{format}', 'json')
          path_params = {}
  
          query_params = {}
  
          header_params = {}
          if 'requester_id' in params:
              header_params['requesterId'] = params['requester_id']
          if 'access_token' in params:
              header_params['accessToken'] = params['access_token']
          if 'client_token' in params:
              header_params['clientToken'] = params['client_token']
  
          form_params = []
          local_var_files = {}
          if 'unfollower' in params:
              form_params.append(('unfollower', params['unfollower']))
          if 'unfollowee' in params:
              form_params.append(('unfollowee', params['unfollowee']))
  
          body_params = None
  
          # HTTP header `Accept`
          header_params['Accept'] = self.api_client.\
              select_header_accept(['application/json'])
          if not header_params['Accept']:
              del header_params['Accept']
  
          # HTTP header `Content-Type`
          header_params['Content-Type'] = self.api_client.\
              select_header_content_type(['application/x-www-form-urlencoded'])
  
          # Authentication setting
          auth_settings = ['default']
  
          return self.api_client.call_api(resource_path, 'POST',
                                              path_params,
                                              query_params,
                                              header_params,
                                              body=body_params,
                                              post_params=form_params,
                                              files=local_var_files,
                                              response_type='bool',
                                              auth_settings=auth_settings,
                                              callback=params.get('callback'),
                                              _return_http_data_only=params.get('_return_http_data_only'))
  