Start building a DELETE request.

@return a request builder which then can be used to create the actual request.
504871
public <T> HttpClientRequest.Builder<T> delete(final URI uri, final HttpClientResponseHandler<T> httpHandler)
    {
        return new HttpClientRequest.Builder<T>(httpClientFactory, HttpClientMethod.DELETE, uri, httpHandler);
    }
85533
public function deleteRequest()
    {
        $operation = array(
            'API' => 'DeleteBucket',
            'Method' => 'DELETE',
            'Uri' => '/<bucket-name>',
            'Headers' => array(
                'Host' => $this->properties['zone'] . '.' . $this->config->host,
            ),
            'Params' => array(
            ),
            'Elements' => array(
            ),
            'Properties' => $this->properties,
            'Body' => null
        );
        $this->deleteValidate($operation);
        $req = new Request($this->config, $operation);
        return $req;
    }
372488
public <T> HttpClientRequest.Builder<T> perform(final String methodName, final URI uri, final HttpClientResponseHandler<T> httpHandler) {
        final HttpClientMethod method;
        try {
            method = HttpClientMethod.valueOf(methodName.toUpperCase(Locale.ENGLISH));
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Unknown HTTP method type " + methodName, e);
        }

        return new HttpClientRequest.Builder<T>(httpClientFactory, method, uri, httpHandler);
    }
626571
public Builder toBuilder() {
    return newBuilder()
        .setMaxAgeSeconds(maxAgeSeconds)
        .setMethods(methods)
        .setOrigins(origins)
        .setResponseHeaders(responseHeaders);
  }
599301
public ParamConfigBuilder startMethodsExtraParamConfig() {
        Iterator<MethodConfigBuilder> methodConfigBuilders = methodBuilders.values().iterator();
        ParamConfigBuilder[] builders = new ParamConfigBuilder[methodBuilders.size()];
        int i = 0;
        while(methodConfigBuilders.hasNext()){
            builders[i++] = methodConfigBuilders.next().startExtraParamConfig();
        }
        return new CompositeParamConfigBuilder(builders);
    }
412275
public function build(): SetRequestInterceptionRequest
	{
		$instance = new SetRequestInterceptionRequest();
		if ($this->patterns === null) {
			throw new BuilderException('Property [patterns] is required.');
		}
		$instance->patterns = $this->patterns;
		return $instance;
	}
1112740
@RequestMapping(value = "builds/{buildId}/links/{targetBuildId}", method = RequestMethod.DELETE)
    public Build deleteBuildLink(@PathVariable ID buildId, @PathVariable ID targetBuildId) {
        Build build = structureService.getBuild(buildId);
        Build targetBuild = structureService.getBuild(targetBuildId);
        structureService.deleteBuildLink(build, targetBuild);
        return build;
    }
271794
public function build(): RequestCachedResponseRequest
	{
		$instance = new RequestCachedResponseRequest();
		if ($this->cacheId === null) {
			throw new BuilderException('Property [cacheId] is required.');
		}
		$instance->cacheId = $this->cacheId;
		if ($this->requestURL === null) {
			throw new BuilderException('Property [requestURL] is required.');
		}
		$instance->requestURL = $this->requestURL;
		if ($this->requestHeaders === null) {
			throw new BuilderException('Property [requestHeaders] is required.');
		}
		$instance->requestHeaders = $this->requestHeaders;
		return $instance;
	}
477405
public <T extends Message> ObjectOrStatus<T> delete(T.Builder builder, String path)
      throws ApiException, IOException {
    return request(builder, path, "DELETE", null, null, null);
  }
103474
public DeleteRequestBuilder<T,ID> delete(List<ID> ids)
    {
        return new DeleteRequestBuilder<T, ID>(version,type,entityName, (ID[]) ids.toArray(new Serializable[ids.size()]));
    }
426093
def delete(self, service, path, **kwargs):
        
        return self.make_request(Methods.DELETE, service, path, **kwargs)
389825
public DeleteMessageResult deleteMessageSync(DeleteMessageRequest request) {
        Future<DeleteMessageResult> future = deleteMessage(request, null);
        return waitForFuture(future);
    }
1256452
public function build(): RemoveAttributeRequest
	{
		$instance = new RemoveAttributeRequest();
		if ($this->nodeId === null) {
			throw new BuilderException('Property [nodeId] is required.');
		}
		$instance->nodeId = $this->nodeId;
		if ($this->name === null) {
			throw new BuilderException('Property [name] is required.');
		}
		$instance->name = $this->name;
		return $instance;
	}
1222693
public function deleteAction()
    {
        $request = $this->getRequest();

        $model = $this->getModel();
        $model->applyRequest($request);

        if ($model->getFilter()) {
            $model->delete();
        } else {
            $this->addMessage($this->_('Empty delete request not allowed'));
        }
        $this->_reroute(array($request->getActionKey() => 'index', MUTil_Model::REQUEST_ID => null));
    }
441090
public final ControlDeleteDurable createNewControlDeleteDurable() throws MessageCreateFailedException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "createNewControlDeleteDurable");
    ControlDeleteDurable msg = null;
    try {
      msg = new ControlDeleteDurableImpl(MfpConstants.CONSTRUCTOR_NO_OP);
    }
    catch (MessageDecodeFailedException e) {
      /* No need to FFDC this as JsMsgObject will already have done so */
      // No FFDC code needed
      throw new MessageCreateFailedException(e);
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "createNewControlDeleteDurable");
    return msg;
  }
529084
protected HttpRequestFactory buildHttpRequestFactory() {
		HttpRequestFactory request = this.getGloboDns().getHttpTransport().createRequestFactory(new HttpRequestInitializer() {
			@Override
			public void initialize(HttpRequest request) throws IOException {
				request.setNumberOfRetries(AbstractAPI.this.globoDns.getNumberOfRetries());
				request.setConnectTimeout(AbstractAPI.this.globoDns.getConnectionTimeout());
				request.setReadTimeout(AbstractAPI.this.globoDns.getReadTimeout());
				request.setThrowExceptionOnExecuteError(false);
				request.setParser(parser);
				request.setLoggingEnabled(true);
				request.getHeaders().setUserAgent("GloboDNS-Client");
				request.setCurlLoggingEnabled(true);
				request.setUnsuccessfulResponseHandler(new HttpUnsuccessfulResponseHandler() {
					
					@Override
					public boolean handleResponse(HttpRequest request, HttpResponse response,
							boolean supportsRetry) throws IOException {
						if (response.getStatusCode() == 401) {
							getGloboDns().clearToken();
							
							if (supportsRetry) {
								// only if supports retry I will prepare request with a new token, and ask to retry
								insertAuthenticationHeaders(request);
								return true;
							}
						}
						return false;
					}
				});
				request.setResponseInterceptor(new HttpResponseInterceptor() {
					@Override
					public void interceptResponse(HttpResponse response) throws IOException {
						AbstractAPI.this.interceptResponse(response);
					}
				});
				interceptRequest(request);
			}
		});
		return request;
	}
1017974
protected function createRequest()
    {
        $request = $this->requestFactory->createRequest($this->method, $this->getEndpoint());

        return $this->queryHelper->applyToRequest($request);
    }