Facebook API Request with "DELETE" method.

@param  string $path
@param  string|null|mixed $parameters
@param  string|null|mixed $version
@param  string|null|mixed $etag
@return mixed
762647
public function delete($path, $parameters = null, $version = null, $etag = null)
        {
            return $this->api('DELETE', $path, $parameters, $version, $etag);
        }
815057
public function delete($path, array $parameters = [], array $requestHeaders = [])
    {
        $response = $this->getHttpClient()->delete($path, $requestHeaders, $this->createJsonBody($parameters));

        return ResponseMediator::getContent($response);
    }
794360
protected Response httpDelete(String path, int status) {
        return httpRequest(status, null).delete(baseURL + PATH_PREFIX + path);
    }
515190
private function _deleteEntity($path)
    {
        $method = Resources::HTTP_DELETE;
        $headers = [];
        $postParams = [];
        $queryParams = [];
        $statusCode = Resources::STATUS_NO_CONTENT;

        $this->sendHttp(
            $method,
            $headers,
            $queryParams,
            $postParams,
            $path,
            $statusCode
        );
    }
600122
public function delete($url, $parameters = []) {
        $this->setRequestMethod('DELETE');
        $this->setURL($this->buildURL($url, $parameters));

        return $this->run();
    }
949511
public function delete( $path, callable $callback ) {
        $route = new Route( 'DELETE', $path, $callback );
        $this->_routes[] = $route;
        return $route;
    }
377968
public function deleteVersionAction(Request $request, $id, $version)
    {
        $locale = $this->getRequestParameter($request, 'locale', true);
        $mediaManager = $this->getMediaManager();
        $media = $mediaManager->getById($id, $locale);

        if ($media->getVersion() === (int) $version) {
            throw new BadRequestHttpException('Can\'t delete active version of a media.');
        }

        $currentFileVersion = null;

        /** @var Media $mediaEntity */
        foreach ($media->getFile()->getFileVersions() as $fileVersion) {
            if ($fileVersion->getVersion() === (int) $version) {
                $currentFileVersion = $fileVersion;
                break;
            }
        }

        if (!$currentFileVersion) {
            throw new NotFoundHttpException(sprintf(
                'Version "%s" for Media "%s"',
                $version,
                $id
            ));
        }

        $entityManager = $this->get('doctrine.orm.entity_manager');
        $entityManager->remove($currentFileVersion);
        $entityManager->flush();
        // After successfully delete in the database remove file from storage
        $this->get('sulu_media.storage')->remove($currentFileVersion->getStorageOptions());

        return new Response('', 204);
    }
1302212
public function delete($path, $default = null, $associative_return = false, $default_on_404 = true)
	{
		try {
			return $this->call(self::DELETE, $path, null, $associative_return);
		} catch (StatusCodeException $e) {
			if ($e->getCode() !== 404 || !$default_on_404) {
				throw $e;
			}
		}

		return $default;
	}
640138
public function delete(string $path, $handler)
  {
    return $this->request($path, Request::HTTP_DELETE, $handler);
  }
1203904
public function delete($path)
    {
        if ($file = $this->getFileObject($path)) {
            $name = $file->getName();
            list ($parentId, $id) = $this->splitPath($path);
            if ($parents = $file->getParents()) {
                $file = new Google_Service_Drive_DriveFile();
                $opts = [];
                $res = false;
                if (count($parents) > 1) {
                    $opts['removeParents'] = $parentId;
                } else {
                    if ($this->options['deleteAction'] === 'delete') {
                        try {
                            $this->service->files->delete($id);
                        } catch (Google_Exception $e) {
                            return false;
                        }
                        $res = true;
                    } else {
                        $file->setTrashed(true);
                    }
                }
                if (!$res) {
                    try {
                        $this->service->files->update($id, $file, $this->applyDefaultParams($opts, 'files.update'));
                    } catch (Google_Exception $e) {
                        return false;
                    }
                }
                unset($this->cacheFileObjects[$id], $this->cacheHasDirs[$id], $this->cacheFileObjectsByName[$parentId . '/' . $name]);
                return true;
            }
        }
        return false;
    }
1087417
public function delete(ResourceManager $resourceManager, ApiRequest $request, int $version, string $resource, $id)
    {
        $resourceManager->version($version);

        /** @var \Ipunkt\LaravelJsonApi\Contracts\RequestHandlers\HandlesDeleteRequest $handler */
        $handler = $this->initializeHandler($resourceManager, $resource, $request, HandlesDeleteRequest::class);

        $handler->delete($id, $request);

        return $this->respondNoContent();
    }
1101427
public function delete($path)
	{
		$path = Util::normalizePath($path);

		$this->assertPresent($path);

		return $this->adapter->delete($path);
	}
1359891
public function get($path=null,$parameters=null)
    {
        if($parameters){
            foreach($parameters as $key=>$parameter)
                $this->addQuery($key,$parameter);
        }
        return $this->startRequest('GET',$path);
    }
1113432
public function delete(array $parameters = []) {
        if (!$this->canAlter()) {
            throw new Exception('Need index, type, and key to delete a document');
        }
        if (!$this->esClient) {
            throw new Exception('Need ElasticSearch client object for ALTER operations');
        }
        $params = [
            'index' => $this->meta['index'],
            'type' => $this->meta['type'],
            'id' => $this->meta['id']] + $parameters;
        $result = $this->esClient->delete($params);
        return $result;
    }
75610
protected function get($path, array $parameters = [], array $requestHeaders = [])
    {
        $path = $this->preparePath($path, $parameters);

        try {
            $response = $this->client->getHttpClient()->get($path, $requestHeaders);

            return ResponseFormatter::getContent($response);
        } catch (HttpException $e) {
            (new ApiExceptionHandler($e))->handle();
        }
    }
1281133
public function get($path, $parameters = [])
    {
        $request = $this->getRequest(static::HTTP_GET, $path, $parameters);

        return $this->sendRequest($request);
    }
1188128
public function delete($path)
    {
        $paths = is_array($path) ? $path : func_get_args();

        $success = true;

        foreach ($paths as $path) {

            if ($this->isDirectory($path)) {
                $success = $this->laravelFS->deleteDirectory($path);
                continue;
            }
            $success = $this->laravelFS->delete($path);

        }

        return $success;
    }