docs: def send_data(self, endpoint=None, page=1, key=None, filter='default', **kwargs):
          """Sends data to the API.
  
          This call is similar to ``fetch``, but **sends** data to the API instead
          of retrieving it.
  
          Returned data will appear in the ``items`` key of the resulting
          dictionary.
  
          Sending data **requires** that the ``access_token`` is set. This is enforced
          on the API side, not within this library.
  
          :param endpoint: (string) The API end point being called. Available endpoints are listed on
              the official API documentation: http://api.stackexchange.com/docs
  
              This can be as simple as ``fetch('answers')``, to call the answers
              end point
  
              If calling an end point that takes additional parameter, such as `id`s
              pass the ids as a list to the `ids` key:
  
                  .. code-block:: python
  
                      fetch('answers/{}', ids=[1,2,3])
  
              This will attempt to retrieve the answers for the three listed ids.
  
              If no end point is passed, a ``ValueError`` will be raised
          :param page: (int) The page in the results to start at. By default, it will start on
              the first page and automatically paginate until the result set
              reached ``max_pages``.
          :param key: (string) The site you are issuing queries to.
          :param filter: (string) The filter to utilize when calling an endpoint. Different filters
              will return different keys. The default is ``default`` and this will
              still vary depending on what the API returns as default for a
              particular endpoint
          :param kwargs: Parameters accepted by individual endpoints. These parameters
              **must** be named the same as described in the endpoint documentation
          :rtype: (dictionary) A dictionary containing wrapper data regarding the API call
              and the results of the call in the `items` key. If multiple
              pages were received, all of the results will appear in the
              ``items`` tag.
          """
          if not endpoint:
              raise ValueError('No end point provided.')
  
          self._endpoint = endpoint
  
          params = {
              "pagesize": self.page_size,
              "page": page,
              "filter": filter
          }
  
          if self.key:
              params['key'] = self.key
          if self.access_token:
              params['access_token'] = self.access_token
  
          if 'ids' in kwargs:
              ids = ';'.join(str(x) for x in kwargs['ids'])
              kwargs.pop('ids', None)
          else:
              ids = None
  
          params.update(kwargs)
          if self._api_key:
              params['site'] = self._api_key
  
          data = []
  
          base_url = "{}{}/".format(self._base_url, endpoint)
          response = requests.post(base_url, data=params, proxies=self.proxy)
          self._previous_call = response.url
          response = response.json()
  
          try:
              error = response["error_id"]
              code = response["error_name"]
              message = response["error_message"]
              raise StackAPIError(self._previous_call, error, code, message)
          except KeyError:
              pass  # This means there is no error
  
          data.append(response)
          r = []
          for d in data:
              r.extend(d['items'])
          result = {'has_more': data[-1]['has_more'],
                    'page': params['page'],
                    'quota_max': data[-1]['quota_max'],
                    'quota_remaining': data[-1]['quota_remaining'],
                    'items': list(chain(r))}
  
          return result