Delete an endpoint
 @example
   domain.delete_endpoint("id")
511054
def delete_endpoint(endpoint_id)
      endpoint = EndPoint.new({:id => endpoint_id}, @client)
      endpoint.domain_id = id
      endpoint.delete()
    end
1098846
def delete(url, params={}, options={})
      response = connection.delete do |req|
        req.saddle_options = options
        req.url(url, params)
      end
      handle_response(response)
    end
1014855
def remove(self):
        
        LOGGER.debug("Endpoint.remove - " + self.id + " - " + self.url)
        if self.id is None:
            return None
        else:
            if self.id in EndpointService.local_cache_by_id:
                for search_params in EndpointService.local_cache_by_id[self.id]:
                    if search_params in EndpointService.local_cache_by_params.keys():
                        EndpointService.local_cache_by_params.pop(search_params)
                EndpointService.local_cache_by_id.pop(self.id)

            params = SessionService.complete_transactional_req({
                'ID': self.id
            })

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                params['OPERATION'] = 'deleteEndpoint'
                args = {'properties': params}
            else:
                args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}

            response = EndpointService.requester.call(args)

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                response = response.get()

            if response.rc != 0:
                LOGGER.warning(
                    'Endpoint.remove - Problem while deleting endpoint ' + str(self.id) +
                    'Reason: ' + str(response.response_content) + ' - ' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                if response.rc == 500 and ArianeMappingOverloadError.ERROR_MSG in response.error_message:
                    raise ArianeMappingOverloadError("Endpoint.remove",
                                                     ArianeMappingOverloadError.ERROR_MSG)
                # traceback.print_stack()
                return self
            else:
                if self.parent_node is not None:
                    self.parent_node.sync()
                return None
1026218
def do_delete(endpoint, access_token):
    '''
    '''
    headers = {"Authorization": 'Bearer ' + access_token}
    headers['User-Agent'] = get_user_agent()
    return requests.delete(endpoint, headers=headers)
1090615
def _request_delete_dns_record_by_id(self, identifier):
        """"""
        return self._request_internal("Delete_DNS_Record",
                                      domain=self.domain,
                                      record={'id': identifier})
1054185
def delete(reason = nil)
      if token?
        API::Webhook.token_delete_webhook(@token, @id, reason)
      else
        API::Webhook.delete_webhook(@bot.token, @id, reason)
      end
    end
157736
def delete(url)
      parameters = Specification.new(url: Types::URL).parameters(url: url)
      @client.action('/posts/delete', parameters)
      self
    end
971486
def delete(self, domain, delete_subdomains=False):
        
        uri = "/%s/%s" % (self.uri_base, utils.get_id(domain))
        if delete_subdomains:
            uri = "%s?deleteSubdomains=true" % uri
        resp, resp_body = self._async_call(uri, method="DELETE",
                error_class=exc.DomainDeletionFailed, has_response=False)
1342784
def delete_endpoint(self, endpoint_id):
        
        self._validate_uuid(endpoint_id)

        url = "/notification/v1/endpoint/{}".format(endpoint_id)
        response = NWS_DAO().deleteURL(url, self._write_headers())

        if response.status != 204:
            raise DataFailureException(url, response.status, response.data)
        return response.status
74818
def delete(self, endpoint, params=None, version='1.1', json_encoded=False):
        """"""
        return self.request(endpoint, 'DELETE', params=params, version=version, json_encoded=json_encoded)
1096093
public static function delete_endpoint($id) {
        require_capability('moodle/site:config', context_system::instance());
        $endpoint = new endpoint($id);

        // Will throw exceptions on validation failures.
        return $endpoint->delete();
    }
815001
def delete(self, json=None):
        
        return self._call('delete', url=self.endpoint, json=json)
129855
def endpoint_deactivate(endpoint_id):
    
    client = get_client()
    res = client.endpoint_deactivate(endpoint_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
383538
def delete(self, id):
        
        for core in self.endpoints:
            self._send_solr_command(self.endpoints[core], "{\"delete\" : { \"id\" : \"%s\"}}" % (id,))
1038150
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/vlan/%s/', ids)

        return super(ApiVlan, self).delete(url)
454774
def delete(self, ids):
        
        url = build_uri_with_ids('api/v4/ipv6/%s/', ids)
        return super(ApiV4IPv6, self).delete(url)
369705
def delete(self, invoice_id, **kwargs):
        "
        url = "{}/{}".format(self.base_url, invoice_id)
        return self.delete_url(url, {}, **kwargs)