Deletes a list of messages on this channel using bulk delete.
351403
def bulk_delete(ids, strict = false)
      min_snowflake = IDObject.synthesise(Time.now - TWO_WEEKS)

      ids.reject! do |e|
        next unless e < min_snowflake

        message = "Attempted to bulk_delete message #{e} which is too old (min = #{min_snowflake})"
        raise ArgumentError, message if strict

        Discordrb::LOGGER.warn(message)
        true
      end

      API::Channel.bulk_delete_messages(@bot.token, @id, ids)
      ids.size
    end
1123609
public function delete(BulkOperation $bulk, Iterator $records)
    {
        foreach ($records as $record) {
            $bulk->delete([
                'id' => $record->getId(),
                'type' => self::TYPE_NAME
            ], null);
        }
    }
257703
def delete_multiple(self, ids=None, messages=None):
        
        url = "queues/%s/messages" % self.name

        items = None
        if ids is None and messages is None:
             raise Exception('Please, specify at least one parameter.')
        if ids is not None:
           items = [{'id': item} for item in ids]
        if messages is not None:
           items = [{'id': item['id'], 'reservation_id': item['reservation_id']} for item in
                 messages['messages']]

        data = json.dumps({'ids': items})

        result = self.client.delete(url=url, body=data,
                                    headers={'Content-Type': 'application/json'})
        return result['body']
1208480
def remove(self):
        
        self.__bulk.add_delete(self.__selector, _DELETE_ALL,
                               collation=self.__collation)
234727
def clear(self):
        """"""
        url = "queues/%s/messages" % self.name
        result = self.client.delete(url = url,
                                    body = json.dumps({}),
                                    headers={'Content-Type': 'application/json'})

        return result['body']
1010413
def discard_incoming_messages(self):
        
        # Flush any received message so far.
        self.inbox.clear()

        # This allows nesting of discard_incoming_messages() calls.
        previous = self._discard_incoming_messages
        self._discard_incoming_messages = True

        try:
            yield
        finally:
            self._discard_incoming_messages = previous
15899
async def delete(self):
        
        return await self.bot.delete_message(self.chat.id, self.message_id)
24163
def clear_errors():
    
    data = []
    data.append(0x0B)
    data.append(BROADCAST_ID)
    data.append(RAM_WRITE_REQ)
    data.append(STATUS_ERROR_RAM)
    data.append(BYTE2)
    data.append(0x00)
    data.append(0x00)
    send_data(data)
172872
public void clearMessages() {
		MessageModel model = getOrCreateComponentModel();

		if (model.messages != null) {
			model.messages.clear();
		}
	}
738712
def chat_delete(self, *, channel: str, ts: str, **kwargs) -> SlackResponse:
        
        kwargs.update({"channel": channel, "ts": ts})
        return self.api_call("chat.delete", json=kwargs)
539949
public static base_responses delete(nitro_service client, String wlmname[]) throws Exception {
		base_responses result = null;
		if (wlmname != null && wlmname.length > 0) {
			lbwlm deleteresources[] = new lbwlm[wlmname.length];
			for (int i=0;i<wlmname.length;i++){
				deleteresources[i] = new lbwlm();
				deleteresources[i].wlmname = wlmname[i];
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
971819
def delete_message(self, queue, msg_id, claim_id=None):
        
        return queue.delete_message(msg_id, claim_id=claim_id)
1015540
def clear_message_streams(self):
        
        for client in self._clients:
            client.empty()
        for server in self._servers:
            server.empty()
312592
def deleteMessages(self, message_ids):
        
        message_ids = require_list(message_ids)
        data = dict()
        for i, message_id in enumerate(message_ids):
            data["message_ids[{}]".format(i)] = message_id
        r = self._post(self.req_url.DELETE_MESSAGES, data)
        return r.ok
1116883
@Deprecated
	public void delete(Collection<Channel.Builder> channels)
			throws ChannelFinderException {
		for (Channel.Builder channel : channels) {
			deleteChannel(channel.build().getName());
		}
	}
633779
public void purge() {
        SortedQueue queue = getQueue();
        _eventStore.purge(_writeChannel);
        queue.clear();
        _eventStore.purge(_readChannel);
    }
343004
def discard_unused_messages(self, ending_tier):
        

        stacks = [self.errors, self.warnings, self.notices]
        for stack in stacks:
            for message in stack:
                if message['tier'] > ending_tier:
                    stack.remove(message)