Use this API to delete snmptrap.
481465
public static base_response delete(nitro_service client, snmptrap resource) throws Exception {
		snmptrap deleteresource = new snmptrap();
		deleteresource.trapclass = resource.trapclass;
		deleteresource.trapdestination = resource.trapdestination;
		return deleteresource.delete_resource(client);
	}
1326530
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            metrics_context = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        hmc.metrics_contexts.remove(metrics_context.oid)
272416
def remove(self, sid):
        
        self.dbcur.execute(SQL_SENSOR_DEL, (sid,))
        self.dbcur.execute(SQL_TMPO_DEL, (sid,))
711222
def delete(args):
        """"""
        mgr = NAppsManager()
        for napp in args['<napp>']:
            mgr.set_napp(*napp)
            LOG.info('Deleting NApp %s from server...', mgr.napp_id)
            try:
                mgr.delete()
                LOG.info('  Deleted.')
            except requests.HTTPError as exception:
                if exception.response.status_code == 405:
                    LOG.error('Delete Napp is not allowed yet.')
                else:
                    msg = json.loads(exception.response.content)
                    LOG.error('  Server error: %s - ', msg['error'])
962989
def DeleteMetricDescriptor(self, request, context):
        
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")
997530
public static base_responses delete(nitro_service client, String Dnssuffix[]) throws Exception {
		base_responses result = null;
		if (Dnssuffix != null && Dnssuffix.length > 0) {
			dnssuffix deleteresources[] = new dnssuffix[Dnssuffix.length];
			for (int i=0;i<Dnssuffix.length;i++){
				deleteresources[i] = new dnssuffix();
				deleteresources[i].Dnssuffix = Dnssuffix[i];
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
1068249
public void delete(final String webhookId) throws OpenpayServiceException, ServiceUnavailableException {
		String path = String.format(DELETE_PATH, this.getMerchantId(), webhookId);
		this.getJsonClient().delete(path);
	}
1336017
def delete(self, request, bot_id, id, format=None):
        
        return super(HookDetail, self).delete(request, bot_id, id, format)
64985
def delete_webhook(self):
        
        api = self._get_api(mds.NotificationsApi)
        api.deregister_webhook()

        # Every subscription will be deleted, so we can clear the queues too.
        self._queues.clear()
        return
122719
def cleanup(self):
        """"""
        for item in self.server_map:
            self.member_del(item, reconfig=False)
        self.server_map.clear()
227863
def delete_simple_httpauth_read_api(
        request,
        database_name,
        collection_name,
        slug):
    """"""
    ss = get_object_or_404(HTTPAuthReadAPI, database_name=database_name,
                           collection_name=collection_name, slug=slug)
    ss.delete()
    messages.success(request, _("Simple HTTP Auth Read API deleted."))
    return HttpResponseRedirect(
        reverse('djmongo_show_apis',
                args=(ss.database_name, ss.collection_name)))
996877
public static base_response delete(nitro_service client, String trapclass) throws Exception {
		snmptrap deleteresource = new snmptrap();
		deleteresource.trapclass = trapclass;
		return deleteresource.delete_resource(client);
	}
88440
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            resource = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        resource.manager.remove(resource.oid)
455947
def delete(self) :
        """"""
        r = self.connection.session.delete(self.URL)
        data = r.json()
        if not r.status_code == 200 or data["error"] :
            raise DeletionError(data["errorMessage"], data)
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
499060
def delete(self):
        """"""
        response = self.http_request(self._url, 'DELETE')
        if response.status != 204:
            self.raise_http_error(response)
891981
public static base_response delete(nitro_service client, String serverip) throws Exception {
		ntpserver deleteresource = new ntpserver();
		deleteresource.serverip = serverip;
		return deleteresource.delete_resource(client);
	}