@see   PodsAPI::delete_object

Drop a Pod Page

$params['id'] int The page ID
$params['uri'] string The page URI

@param array $params An associative array of parameters

@return bool
@since 1.7.9
961027
public function delete_page( $params ) {

		$params = (object) $params;
		if ( isset( $params->uri ) ) {
			$params->name = $params->uri;
			unset( $params->uri );
		}
		if ( isset( $params->name ) ) {
			$params->name = trim( $params->name, '/' );
		}
		$params->type = 'page';

		return $this->delete_object( $params );
	}
115655
public function Delete ($params = FALSE, &$db = FALSE)
	{
		
		// Get database master for write

		if ($db === FALSE)
		{
			$db	=& $this->getDbMaster ();
		}
		
		// Get objects
		
		$objs	= is_array ($params)? self::_getObjects ($params, $db) : [self::_read ($params, $db)];
		
		// Remove each
		
		$db->beginTransaction ();
		
		foreach ($objs as $obj)
		{
			if (!$obj->Remove ())
			{
				$db->rollBack ();
				return FALSE;
			}
		}
		
		$db->commit ();
		return TRUE;
		
	}
1173348
public function deleteItems( \stdClass $params )
	{
		$this->checkParams( $params, array( 'site', 'items' ) );
		$this->setLocale( $params->site );

		$refIds = [];
		$ids = (array) $params->items;
		$manager = $this->getManager();

		$search = $manager->createSearch();
		$search->setConditions( $search->compare( '==', $this->getPrefix() . '.id', $ids ) );
		$search->setSlice( 0, count( $ids ) );

		foreach( $manager->searchItems( $search ) as $item ) {
			$refIds[$item->getDomain()][] = $item->getRefId();
		}

		$manager->deleteItems( $ids );

		if( isset( $refIds['product'] ) )
		{
			$this->rebuildIndex( (array) $refIds['product'] );
			$this->clearCache( (array) $refIds['product'], 'product' );
		}

		return array(
			'items' => $params->items,
			'success' => true,
		);
	}
600122
public function delete($url, $parameters = []) {
        $this->setRequestMethod('DELETE');
        $this->setURL($this->buildURL($url, $parameters));

        return $this->run();
    }
628556
public function deleteByParams($params = [])
    {
        extract($params);

        $query = $this->newDeleteQuery();

        if (isset($where)) {
            if (is_array($where)) {
                foreach ($where as $condition) {
                    $condition = (array)$condition;
                    $query->where($condition[0], $condition[1]);
                }
            } else {
                call_user_func_array([$query, 'where'], $where);
            }
        }

        if (isset($order)) {
            call_user_func_array([$query, 'order'], $order);
        }

        if (isset($limit)) {
            call_user_func_array([$query, 'limit'], $limit);
        }

        $this->getDB()->execute($query);

        return $this;
    }
636430
public static function cancel($id, $params = null, $options = null)
    {
        $url = static::classUrl().'/'.$id;
        if (empty($params)) {
            $params = ['status' => 'canceled'];
        } else {
            $params = array_merge($params, ['status' => 'canceled']);
        }
        return static::_directRequest('put', $url, $params, $options);
    }
541992
protected function _deleteSingle($requestParams)
    {
        $requiredParams = array("id");
        return $this->client->request($requestParams, $this->_endpoint, "delete", $requiredParams, $options = NULL);
    }
1216429
public function delete($params, $optParams = [])
    {
        if ($params instanceof SuperBackup) {
            $params = $params->id;
        }
        if(!isset($optParams['cloud'])){
            $optParams['cloud'] = [];
        }
        $optParams['cloud']['id'] = $params;
        return $this->sendRequest([], [
            'restAction' => 'delete',
            'uri' => '/c/<cloud.id>',
            'restId' => $params,
            'getParams' => $optParams,
        ], function ($response) {
            return $response->success;
        });
    }
808789
def delete_by(params, request_options = {})
      raise ArgumentError.new('params cannot be nil, use the `clear` method to wipe the entire index') if params.nil?
      params = sanitized_delete_by_query_params(params)
      client.post(Protocol.delete_by_uri(name), params.to_json, :write, request_options)
    end
1004978
public function delete($url, $params = array(), $options = array())
    {
        return $this->request($url, self::DELETE, $params, $options);
    }
62647
public static function delete($token, array $params = array())
    {
        $params = array_merge($params, array('token_id' => $token));

        return self::invoke(__FUNCTION__, static::RESOURCE_NAME, $params);
    }
97122
public function remove(array $params)
    {
        $key = array_get($params, 'key');
        $member = array_get($params, 'member');

        return $this->getConnection()->zrem($key, $member);
    }
555950
public function delete($condition=null, $params=null) {
		return $this->driver->delete($condition, $params);
	}
407843
function DELETE(uri, params) {
	const requestURL = `${uri}${url.format({ query: params })}`;
  log(`request URL: ${requestURL}`);

	return fetch(requestURL, { method: 'DELETE', compress: compress })
    .then(function handleRequest(res) {
      const statusText = res.statusText;
			const status = res.status;
			if (status != 200) {
				const error = new Error(`Request failed: ${statusText}`);
				error.status = status;
				throw error;
			}
			return res.json();
		})
		.catch(error => {
			log(`error: ${error}`);
			throw error;
		});
}
1258109
public function deleteMany($ids = null)
    {
        if (is_null($ids)) {
            $parameters = [
                'performAll' => true
            ];
        } else {
            $parameters = [
                'ids' => implode(',', (array) $ids),
            ];
        }

        $response = $this->ontraport->delete(
            $this->getNamespace(), $this->toArray($parameters)
        );

        // When deleting many objects, we get a string for the data field in the response,
        // saying "Deleted". When an object does not exist, it is ignored by oap. I believe
        // its safe to assume that we can always return successfuly here. Unless we receive
        // a non 200 status code in which case an InvalidRequest would be thrown.

        return true;
    }
560751
public function paginate(array $params)
    {

        // page
        if (isset($params[$this->getParamPage()])) {
            $this->setPage($params[$this->getParamPage()]);
        }

        return $this;
    }
458884
public function delete($path, $params = array()) {
    $request = $this->request();
    $request = $this->prepareRequest($request);

    $response = $request->delete($this->endpoint . $path, $params);
    return $this->handleResponse($response);
  }