Delete an existing message type
        :param message_type_id: is the id of the message type the
                                client wants to delete
541472
def delete_message_type(self, message_type_id):
        
        self._validate_uuid(message_type_id)

        url = "/notification/v1/message-type/{}".format(message_type_id)
        response = NWS_DAO().deleteURL(url, self._write_headers())

        if response.status != 204:
            raise DataFailureException(url, response.status, response.data)
        return response.status
408024
async def deleteMessage(self, msg_identifier):
        
        p = _strip(locals(), more=['msg_identifier'])
        p.update(_dismantle_message_identifier(msg_identifier))
        return await self._api_request('deleteMessage', _rectify(p))
911976
def remove_message(self, message):
        '''
        
        '''
        if message in self.__messages:
            self.__messages.remove(message)
817578
def per_callback_query_chat_id(types='all'):
    
    def f(msg):
        if (flavor(msg) == 'callback_query' and 'message' in msg
            and (types == 'all' or msg['message']['chat']['type'] in types)):
            return msg['message']['chat']['id']
        else:
            return None
    return f
745179
def message(self, message: types.Message):
        
        setattr(self, 'from_chat_id', message.chat.id)
        setattr(self, 'message_id', message.message_id)
        return self
305386
public void typeMissing() {
		this.parameterMissing(
				ProtocolConstants.Parameters.Delete.TYPE,
				"Please provide the type of the delete request. Use \""
						+ DeleteRequestType.USER.getIdentifier()
						+ "\" to delete a user, \""
						+ DeleteRequestType.FOLLOW.getIdentifier()
						+ "\" to delete a follow edge or \""
						+ DeleteRequestType.STATUS_UPDATE.getIdentifier()
						+ "\" to delete a status update.");
	}
13842
def delete_messages(self, ids):
        
        str_ids = self._return_comma_list(ids)
        return self.request('MsgAction', {'action': {'op': 'delete',
                                                     'id': str_ids}})
921667
function delete_message(req, uuid) {
	debug.assert(uuid).is('uuid');
	delete req.session.client.messages[uuid];
}
989859
def publish(self, message_type=ON_SEND, client_id=None, client_storage=None,
                *args, **kwargs):
        
        self.publisher.publish(
            message_type, client_id, client_storage, *args, **kwargs)
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)
1287501
def delete(self, id):
        
        id = self.key_name(id)
        self.redis.delete(id)
600119
def delete(self, main_type, sub_type, unique_id, owner=None):
        
        params = {'owner': owner} if owner else {}
        if not sub_type:
            url = '/v2/{}/{}'.format(main_type, unique_id)
        else:
            url = '/v2/{}/{}/{}'.format(main_type, sub_type, unique_id)
        return self.tcex.session.delete(url, params=params)
1367116
def delete_announcement_view(request, id):
    
    if request.method == "POST":
        post_id = None
        try:
            post_id = request.POST["id"]
        except AttributeError:
            post_id = None
        try:
            a = Announcement.objects.get(id=post_id)
            if request.POST.get("full_delete", False):
                a.delete()
                messages.success(request, "Successfully deleted announcement.")
            else:
                a.expiration_date = datetime.datetime.now()
                a.save()
                messages.success(request, "Successfully expired announcement.")
        except Announcement.DoesNotExist:
            pass

        return redirect("index")
    else:
        announcement = get_object_or_404(Announcement, id=id)
        return render(request, "announcements/delete.html", {"announcement": announcement})
1243311
def delete_message(self, message):
        

        message_id = message.object_id if isinstance(message,
                                                     Message) else message

        if message_id is None:
            raise RuntimeError('Provide a valid Message or a message id')

        url = self.build_url(
            self._endpoints.get('message').format(id=message_id))

        response = self.con.delete(url)

        return bool(response)
636422
def delete(self, resource_id):
        

        endpoint = '{}/{}'.format(self.endpoint, resource_id)

        response = self.api.execute("DELETE", endpoint)

        if not response.ok:
            raise Error.parse(response.json())

        return self._cls.parse(response.json())
1257258
def clear_step_handler(self, message):
        
        chat_id = message.chat.id
        self.clear_step_handler_by_chat_id(chat_id)
975865
def delete_event(self, calendar_id, event_id):
        
        self.request_handler.delete(endpoint='calendars/%s/events' % calendar_id, data={'event_id': event_id})