Delete API method response for a resource in the given API

    CLI Example:

    .. code-block:: bash

        salt myminion boto_apigateway.delete_api_method_response restApiId resourcePath httpMethod statusCode
499934
def delete_api_method_response(restApiId, resourcePath, httpMethod, statusCode,
                               region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        resource = describe_api_resource(restApiId, resourcePath, region=region,
                                         key=key, keyid=keyid, profile=profile).get('resource')
        if resource:
            conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
            conn.delete_method_response(restApiId=restApiId, resourceId=resource['id'],
                                        httpMethod=httpMethod, statusCode=str(statusCode))  # future lint: disable=blacklisted-function
            return {'deleted': True}
        return {'deleted': False, 'error': 'no such resource'}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
426093
def delete(self, service, path, **kwargs):
        
        return self.make_request(Methods.DELETE, service, path, **kwargs)
181598
def do_DELETE(self):
        
        self.do_initial_operations()
        coap_response = self.client.delete(self.coap_uri.path)
        self.client.stop()
        logger.debug("Server response: %s", coap_response.pretty_print())
        self.set_http_response(coap_response)
23478
def delete_response
      url = ApiRequest.base_path("questionpro.survey.deleteResponse")
      result = self.class.get(url, body: self.options)
      
      self.full_response = result
      self.status = result['status']
      self.success = result['response']['success']

      return self       
    end
708784
def delete_service(resource_root, name, cluster_name="default"):
  
  return call(resource_root.delete,
      "%s/%s" % (SERVICES_PATH % (cluster_name,), name),
      ApiService)
963546
async def delete(self, request, resource=None, **kwargs):
        
        if resource:
            resources = [resource]
        else:
            data = await self.parse(request)
            if data:
                resources = list(self.collection.where(self.meta.model_pk << data))

        if not resources:
            raise RESTNotFound(reason='Resource not found')

        for resource in resources:
            resource.delete_instance()
184293
def deleteClient(self, *args, **kwargs):
        

        return self._makeApiCall(self.funcinfo["deleteClient"], *args, **kwargs)
1088080
public static base_responses delete(nitro_service client, String trapclass[]) throws Exception {
		base_responses result = null;
		if (trapclass != null && trapclass.length > 0) {
			snmptrap deleteresources[] = new snmptrap[trapclass.length];
			for (int i=0;i<trapclass.length;i++){
				deleteresources[i] = new snmptrap();
				deleteresources[i].trapclass = trapclass[i];
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
636422
def delete(self, resource_id):
        

        endpoint = '{}/{}'.format(self.endpoint, resource_id)

        response = self.api.execute("DELETE", endpoint)

        if not response.ok:
            raise Error.parse(response.json())

        return self._cls.parse(response.json())
886169
def delete
      success = true
      tries ||= 3
      request = Net::HTTP::Delete.new("/api/projects/#{Connection.api_key}/terms/#{self.id}")
      WebTranslateIt::Util.add_fields(request)
      begin
        Util.handle_response(Connection.http_connection.request(request), true, true)
      rescue Timeout::Error
        puts "Request timeout. Will retry in 5 seconds."
        if (tries -= 1) > 0
          sleep(5)
          retry
        else
          success = false
        end
      end
      success
    end
1336017
def delete(self, request, bot_id, id, format=None):
        
        return super(HookDetail, self).delete(request, bot_id, id, format)
1127126
public static base_responses delete(nitro_service client, location resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			location deleteresources[] = new location[resources.length];
			for (int i=0;i<resources.length;i++){
				deleteresources[i] = new location();
				deleteresources[i].ipfrom = resources[i].ipfrom;
				deleteresources[i].ipto = resources[i].ipto;
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
983959
def _api_delete(self, api_key=None, **kwargs):
		
		api_key = api_key or self.default_api_key

		return self.api_retrieve(api_key=api_key).delete(**kwargs)
374554
def delete(resource_path)
      response = @http_client[resource_path].delete
      Response.new(response)
    rescue => err
      raise communication_error err
    end
1225981
def delete_request(url, params)
      begin
        resource_url = "#{@base_uri}#{url}?access_token=#{@access_token}&#{params}"
        response = RestClient.delete resource_url, {content_type: :json, accept: :json}

        #result = JSON.parse(response, object_class: OpenStruct)
        return response
      rescue => e
        return JSON.parse(e.response, object_class: OpenStruct)
      end
    end
652138
def _api_delete(self, url, **kwargs):
        
        kwargs['url'] = self.url + url
        kwargs['auth'] = self.auth

        headers = deepcopy(self.headers)
        headers.update(kwargs.get('headers', {}))
        kwargs['headers'] = headers
        self._delete(**kwargs)
710776
def remove_api_key(self, api_id, stage_name):
        
        response = self.apigateway_client.get_api_keys(
            limit=1,
            nameQuery='{}_{}'.format(stage_name, api_id)
        )
        for api_key in response.get('items'):
            self.apigateway_client.delete_api_key(
                apiKey="{}".format(api_key['id'])
            )