Makes http DELETE request
@param url url to makes request to
@param params data to add to params field
@return {@link okhttp3.Response}
@throws RequestException
@throws LocalOperationException
548179
okhttp3.Response delete(String url, Map<String, Object> params)
            throws RequestException, LocalOperationException {
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(getFullUrl(url))
                .delete(getBody(toPayload(params), null))
                .addHeader("Transloadit-Client", version)
                .build();

        try {
            return httpClient.newCall(request).execute();
        } catch (IOException e) {
            throw new RequestException(e);
        }
    }
268038
public void DELETE(String partialUrl, Map<String, Object> headers, 
        List<String> queryParams)
    {
        URI uri = buildUri(partialUrl);
        executeDeleteRequest(uri, headers, queryParams);
    }
101121
public static KieServerHttpRequest deleteRequest(final URL url ) throws KieServerHttpRequestException {
        KieServerHttpRequest request = new KieServerHttpRequest(url);
        request.getRequestInfo().requestMethod = DELETE;
        return request;
    }
497072
@RequestMapping(value = "/delete", method = RequestMethod.POST)
	public @ResponseBody
	void delete(
			@RequestParam(value = "username", required = true) String username,
			HttpServletResponse response) {
		logger.debug("Received request to delete account");

		ResponseAccount responseAccount = accountService
				.getAccountByUsername(username);
		if (responseAccount.getAccount() == null) {
			try {
				response.sendError(500, "No such user exists: " + username);
			} catch (IOException e) {
				e.printStackTrace();
				return;
			}
			return;
		}
		accountService.delete(responseAccount.getAccount());

	}
1092189
public PurgeResponse purge(String url) {
        return purge(new PurgeRequest().addTask(new PurgeTask().withUrl(url)));
    }
1097647
@Override
    public String delete(EntityDeleteOperation deleter) throws ServiceException {
        deleter.setProxyData(createProxyData());
        ClientResponse clientResponse =  getResource(deleter.getUri()).delete(ClientResponse.class);
        PipelineHelpers.throwIfNotSuccess(clientResponse);
        if (clientResponse.getHeaders().containsKey("operation-id")) {
            List<String> operationIds = clientResponse.getHeaders().get("operation-id");
            if (operationIds.size() >= 0) {
                return operationIds.get(0);
            }
        }
        return null;
    }
1333956
public RestResponse delete(final String uri) throws IOException, AppPlatformException {
        return request(getPath(uri), HttpDelete.METHOD_NAME);
    }
863966
public HttpClient delete(String url) throws HelloSignException {
        request = new HttpDeleteRequest(url, auth);
        request.execute();
        return this;
    }
1371751
public function delete($url, array $headers = [], array $params = [])
    {
        return $this->instance->createHttpClient()->delete($url, $headers, $params);
    }
1098846
def delete(url, params={}, options={})
      response = connection.delete do |req|
        req.saddle_options = options
        req.url(url, params)
      end
      handle_response(response)
    end
1019839
public ApiResponse<MetadataEnvelope> deleteServerPropertiesWithHttpInfo(String did) throws ApiException {
        com.squareup.okhttp.Call call = deleteServerPropertiesValidateBeforeCall(did, null, null);
        Type localVarReturnType = new TypeToken<MetadataEnvelope>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
614183
def _delete(self, url):
        """"""
        r = requests.delete(self._api_prefix + url,
            headers=self.headers,
            auth=self.auth,
            allow_redirects=False,
        )
        return self._action(r)
111007
public XcapResponse delete(URI uri, Header[] additionalRequestHeaders,
			Credentials credentials) throws IOException {

		if (log.isDebugEnabled()) {
			log.debug("delete(uri=" + uri + " , additionalRequestHeaders = ( "
					+ Arrays.toString(additionalRequestHeaders) + " ) )");
		}

		return execute(new HttpDelete(uri), additionalRequestHeaders,
				credentials);
	}
141146
public JSONObject deleteBy(Query query, RequestOptions requestOptions) throws AlgoliaException {
    String paramsString = query.getQueryString();
    JSONObject body = new JSONObject();
    try {
      body.put("params", paramsString);
    } catch (JSONException e) {
      throw new RuntimeException(e);
    }
    return client.postRequest("/1/indexes/" + encodedIndexName + "/deleteByQuery", body.toString(), false, false, requestOptions);
  }
807908
public HttpRequest buildDeleteRequest(GenericUrl url) throws IOException {
    return buildRequest(HttpMethods.DELETE, url, null);
  }
844084
public ApiResponse<Integer> executeDeletePostWithHttpInfo(Query query) throws ApiException {
        com.squareup.okhttp.Call call = executeDeletePostValidateBeforeCall(query, null, null);
        Type localVarReturnType = new TypeToken<Integer>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
519861
@Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int result = -1;

        if (!controller.hasPreinitialized()) {
            throw new IllegalStateException("Controller has not been initialized.");
        }

        int patternCode = controller.getUriMatcher().match(uri);
        MatcherPattern pattern = controller.findMatcherPattern(patternCode);
        if (pattern == null) {
            throw new IllegalArgumentException("unknown uri : " + uri.toString());
        }

        Parameter parameter = new Parameter(uri, selection, selectionArgs);
        SQLiteDatabase db = this.getHelper().getWritableDatabase();

        result = onDelete(this.getHelper(), db, pattern, parameter);
        if (result >= 0) {
            this.onDeleteCompleted(result, uri, pattern, parameter);
        }
        return result;
    }