Make a DELETE API call.

@param path
The GET path. Include the GET parameters after ?
@return A JSON object.
@throws APIError
If an error occurs.
176699
public JSONObject delete(String path) throws APIError {
        return request(Verb.DELETE, path, null);
    }
272761
def delete(path, options = {}, headers = {}, raw = false)
      request(:delete, path, options, headers, raw)
    end
1098094
@DELETE
    @Path("/{id}")
    public Response delete(@PathParam("id") final String id)
            throws IOException {
        return execute(getResourceRequest(RequestTypeEnum.DELETE, RestOperationTypeEnum.DELETE).id(id));
    }
392399
public Response delete(String path, Map<String, String> headers) throws IOException, RESTException {
        return parseResponse(getHttpResponse(new HttpDelete(baseUrl + path), headers));
    }
1193717
protected function delete(string $path, array $params = [], array $headers = [])
    {
        $body = self::createJsonBody($params);

        if ($body) {
            $headers = self::addJsonContentType($headers);
        }

        return $this->deleteRaw($path, $body, $headers);
    }
371522
def delete(self, data, *args):
        
        path = self.get_resource_name()
        result = self.perform_api_call(self.REST_DELETE, path, data=data)
        return result
389324
public <T extends Message> ObjectOrStatus<T> delete(
      T.Builder builder, String path, DeleteOptions deleteOptions)
      throws ApiException, IOException {
    if (deleteOptions == null) {
      return delete(builder, path);
    }

    HashMap<String, String> headers = new HashMap<>();
    headers.put("Content-Type", MEDIA_TYPE);
    headers.put("Accept", MEDIA_TYPE);
    String[] localVarAuthNames = new String[] {"BearerToken"};
    Request request =
        apiClient.buildRequest(
            path,
            "DELETE",
            new ArrayList<Pair>(),
            new ArrayList<Pair>(),
            null,
            headers,
            new HashMap<String, Object>(),
            localVarAuthNames,
            null);
    byte[] bytes = encode(deleteOptions, "v1", "DeleteOptions");
    request =
        request.newBuilder().delete(RequestBody.create(MediaType.parse(MEDIA_TYPE), bytes)).build();
    Response resp = apiClient.getHttpClient().newCall(request).execute();
    Unknown u = parse(resp.body().byteStream());
    resp.body().close();

    if (u.getTypeMeta().getApiVersion().equals("v1")
        && u.getTypeMeta().getKind().equals("Status")) {
      Status status = Status.newBuilder().mergeFrom(u.getRaw()).build();
      return new ObjectOrStatus(null, status);
    }

    return new ObjectOrStatus((T) builder.mergeFrom(u.getRaw()).build(), null);
  }
1099783
def delete(path, params = {})
      headers = request_headers(:delete, path, params)
      request(:delete, path, params, headers)
    end
1204819
protected RestResponse requestJson(final String path, final String method, final String param)
            throws IOException, AppPlatformException {
        final HttpUriRequest request = setupRequestJson(path, method, param);
        return performRequest(request);
    }
782250
public static boolean del(Path path) throws IORuntimeException {
		if (Files.notExists(path)) {
			return true;
		}

		try {
			if (Files.isDirectory(path)) {
				Files.walkFileTree(path, new SimpleFileVisitor<Path>() {

					@Override
					public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
						Files.delete(file);
						return FileVisitResult.CONTINUE;
					}

					@Override
					public FileVisitResult postVisitDirectory(Path dir, IOException e) throws IOException {
						if (e == null) {
							Files.delete(dir);
							return FileVisitResult.CONTINUE;
						} else {
							throw e;
						}
					}
				});
			} else {
				Files.delete(path);
			}
		} catch (IOException e) {
			throw new IORuntimeException(e);
		}
		return true;
	}
832027
public Response invokeDelete(String resourcePath, MultivaluedMap<String, String> params) {
		logger.debug("DELETE {}, params: {}", getFullPath(resourcePath), params);
		return invokeSignedRequest(getApiClient(), accessKey, key(true), DELETE,
				getEndpoint(), getFullPath(resourcePath), null, params, new byte[0]);
	}
1039478
public static void decompress(String path, boolean delete) throws Exception {
		File file = new File(path);
		decompress(file, delete);
	}
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)
444068
public boolean delete(Path path, boolean recursive) throws IOException {
      Path absolute = makeAbsolute(path);
      String srep = absolute.toUri().getPath();
      if (kfsImpl.isFile(srep))
        return kfsImpl.remove(srep) == 0;

      FileStatus[] dirEntries = listStatus(absolute);
      if ((!recursive) && (dirEntries != null) && 
            (dirEntries.length != 0)) {
        throw new IOException("Directory " + path.toString() + 
        " is not empty.");
      }
      if (dirEntries != null) {
        for (int i = 0; i < dirEntries.length; i++) {
          delete(new Path(absolute, dirEntries[i].getPath()), recursive);
        }
      }
      return kfsImpl.rmdir(srep) == 0;
    }
682762
public<T> Delete<T> delete(Class<T> cls) throws APIException {
		return new Delete<T>(this,getDF(cls));
	}
604843
public Javalin delete(@NotNull String path, @NotNull Handler handler) {
        return addHandler(HandlerType.DELETE, path, handler);
    }
290789
@Deprecated
    public String get(String path) {
        final JsonValue value = this.values.get(this.pathToProperty(path));
        if (value == null) {
            return null;
        }
        if (!value.isString()) {
            return value.toString();
        }
        return value.asString();
    }