Delete an object from the index

 @param objectID the unique identifier of object to delete
 @param request_options contains extra parameters to send with your query
344483
def delete_object(objectID, request_options = {})
      raise ArgumentError.new('objectID must not be blank') if objectID.nil? || objectID == ''
      client.delete(Protocol.object_uri(name, objectID), :write, request_options)
    end
478801
def delete_link(obj, options = {})
      if policy(obj).destroy?
        default_options = { data: {
          confirm: 'Are you sure? There is no undo for this!',
          tooltip: 'Delete',
          method: 'Delete',
          remote: 'true'
        } }
        url = polymorphic_url(obj)
        action_link('Delete', url, 'trash-o', default_options.deep_merge(options))
      end
    end
1305557
def ng_delete(self, request, *args, **kwargs):
        
        if 'pk' not in request.GET:
            raise NgMissingParameterError("Object id is required to delete.")

        obj = self.get_object()
        response = self.build_json_response(obj)
        obj.delete()
        return response
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
794397
def delete(options = {})
      options = options.merge(db_cluster_parameter_group_name: @name)
      resp = @client.delete_db_cluster_parameter_group(options)
      resp.data
    end
828708
public synchronized void remove(int requestId)
   {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "remove");
		
      if (!containsId(requestId))
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) debugTraceTable("id ("+requestId+") not in table");
         throw new SIErrorException(nls.getFormattedMessage("REQIDTABLE_INTERNAL_SICJ0058", null, "REQIDTABLE_INTERNAL_SICJ0058")); // D226223
      }

      testReqIdTableEntry.requestId = requestId;
      table.remove(testReqIdTableEntry);

		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "remove");
   }
731444
public JSONObject deleteSynonym(String objectID, boolean forwardToReplicas, RequestOptions requestOptions) throws AlgoliaException {
    if (objectID == null || objectID.length() == 0) {
      throw new AlgoliaException("Invalid objectID");
    }
    try {
      return client.deleteRequest("/1/indexes/" + encodedIndexName + "/synonyms/" + URLEncoder.encode(objectID, "UTF-8") + "/?page=forwardToReplicas" + forwardToReplicas, requestOptions);
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }
931525
def delete(options = {})
      options = options.merge(queue_url: @url)
      resp = @client.delete_queue(options)
      resp.data
    end
819338
def delete(options = {})
      options = options.merge(user_name: @name)
      resp = @client.delete_user(options)
      resp.data
    end
1173710
def delete!(request_options = {})
      res = delete(request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options)
      res
    end
1349038
public JSONObject deleteSynonym(String objectID, RequestOptions requestOptions) throws AlgoliaException {
    return deleteSynonym(objectID, false, requestOptions);
  }
1061932
def delete(self, request, id=None):
        
        if id:
            obj = get_object_or_404(self.queryset(request), id=id)
            if not self.has_delete_permission(request, obj):
                return HttpResponseForbidden(_('You do not have permission to perform this action.'))
            else:
                return self.delete_object(request, obj)
        else:
            # No delete requests allowed on collection view
            return HttpResponseForbidden()
328582
function(filterIndex, options) {
      if (options === undefined) {
        throw new Error('Request filter at index ' + filterIndex + ' returned nothing; it must return the filtered request options');
      } else if (!_.isObject(options)) {
        throw new Error('Expected request filter at index ' + filterIndex + ' to return the request options as an object, got ' + typeof(options));
      }

      return options;
    }
1021525
@Indexable(type = IndexableType.DELETE)
	@Override
	public CPOptionValue deleteCPOptionValue(CPOptionValue cpOptionValue)
		throws PortalException {
		return cpOptionValuePersistence.remove(cpOptionValue);
	}
1302655
def delete(cls, id, api_key=None, **kwargs):
        """"""
        inst = cls(api_key=api_key)
        endpoint = '/'.join((cls.get_endpoint(), id))
        inst.request('DELETE', endpoint=endpoint, query_params=kwargs)
        inst._is_deleted = True
        return True
1098846
def delete(url, params={}, options={})
      response = connection.delete do |req|
        req.saddle_options = options
        req.url(url, params)
      end
      handle_response(response)
    end
982472
def delete(options = {})
      options = options.merge(
        role_name: @role_name,
        policy_name: @name
      )
      resp = @client.delete_role_policy(options)
      resp.data
    end