Delete API method for a resource in the given API

    CLI Example:

    .. code-block:: bash

        salt myminion boto_apigateway.delete_api_method restApiId resourcePath httpMethod
519500
def delete_api_method(restApiId, resourcePath, httpMethod, 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(restApiId=restApiId, resourceId=resource['id'], httpMethod=httpMethod)
            return {'deleted': True}
        return {'deleted': False, 'error': 'get API method failed: no such resource'}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
1333956
public RestResponse delete(final String uri) throws IOException, AppPlatformException {
        return request(getPath(uri), HttpDelete.METHOD_NAME);
    }
1231249
def fetch_method(api_id, resource_id, verb):
    
    return console.get_method(
            restApiId=api_id,
            resourceId=resource_id,
            httpMethod=verb)
272019
def delete(self, resource_id, **kwargs):
        

        return self.client._delete(self._url(resource_id), **kwargs)
962162
def delete(query_url,
               headers: {},
               parameters: {})
      HttpRequest.new(HttpMethodEnum::DELETE,
                      query_url,
                      headers: headers,
                      parameters: parameters)
    end
4183
def group_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/groups/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
932308
def invalidate_api_key(self, body, params=None):
        
        if body in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'body'.")
        return self.transport.perform_request(
            "DELETE", "/_security/api_key", params=params, body=body
        )
970952
def delete(cls, id):
        '''
        
        '''
        client = cls._new_api_client()
        return client.make_request(cls, 'delete', url_params={'id': id})
869565
public DeleteMetadataResponse deleteMetadata(String location) throws ApiException {
        ApiResponse<DeleteMetadataResponse> resp = deleteMetadataWithHttpInfo(location);
        return resp.getData();
    }
470423
def delete_api_stage(restApiId, stageName, region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        conn.delete_stage(restApiId=restApiId, stageName=stageName)
        return {'deleted': True}
    except ClientError as e:
        return {'deleted': False, 'error': __utils__['boto3.get_error'](e)}
959035
def app_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/apps/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
1302655
def delete(cls, id, api_key=None, **kwargs):
        """"""
        inst = cls(api_key=api_key)
        endpoint = '/'.join((cls.get_endpoint(), id))
        inst.request('DELETE', endpoint=endpoint, query_params=kwargs)
        inst._is_deleted = True
        return True
670688
def delete_simple_public_read_api(
        request,
        database_name,
        collection_name,
        slug):
    """"""
    ss = get_object_or_404(PublicReadAPI, database_name=database_name,
                           collection_name=collection_name, slug=slug)
    ss.delete()
    messages.success(request, _("Simple Public Read API deleted."))
    return HttpResponseRedirect(
        reverse('djmongo_show_apis',
                args=(ss.database_name, ss.collection_name)))
1047547
def macro_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/macros/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
987270
def delete(self, resource_id):
        
        resource = self._resource(resource_id)
        error_message = is_valid_method(self.__model__, resource)
        if error_message:
            raise BadRequestException(error_message)
        db.session().delete(resource)
        db.session().commit()
        return self._no_content_response()
962286
def delete(self, context):
	
		
		
		encoded_name = urllib.parse.quote_plus(self.__name)
		status_code, msg = self.__endpoint.delete(
			"/resources/custom-resource/{}".format(encoded_name)
		)
		self.__available = False
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