// DELETE rest call
490255
func httpDeleteGlobal(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
	log.Debugf("Received httpDeleteGlobal: %+v", vars)

	key := vars["key"]

	// Delete the object
	err := DeleteGlobal(key)
	if err != nil {
		log.Errorf("DeleteGlobal error for: %s. Err: %v", key, err)
		return nil, err
	}

	// Return the obj
	return key, nil
}
1282201
func (s *ProbesService) Delete(k ProbeKey) (*http.Response, error) {
	return s.client.delete(k.URI(), nil)
}
311645
func (mr *MockRenderedJobListArchiveMockRecorder) Delete() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRenderedJobListArchive)(nil).Delete))
}
678771
func (t *Manager) Delete(api Definition) {
	key := t.GetMethodPatternKey(t, api)
	delete(t.apiMethodPatternMap, key)
}
624409
func Delete(c *messagebird.Client, id string) (*Message, error) {
	message := &Message{}
	if err := c.Request(message, http.MethodDelete, path+"/"+id, nil); err != nil {
		return nil, err
	}

	return message, nil
}
513699
func (s *ObjectsClient) Delete(ctx context.Context, input *DeleteObjectInput) error {
	absPath := absFileInput(s.client.AccountName, input.ObjectPath)

	headers := &http.Header{}
	for key, value := range input.Headers {
		headers.Set(key, value)
	}

	reqInput := client.RequestInput{
		Method:  http.MethodDelete,
		Path:    string(absPath),
		Headers: headers,
	}
	respBody, _, err := s.client.ExecuteRequestStorage(ctx, reqInput)
	if respBody != nil {
		defer respBody.Close()
	}
	if err != nil {
		return errors.Wrap(err, "unable to delete object")
	}

	return nil
}
393905
func (k *Client) Delete(targetURL string) {
	k.ClearClient()
	k.Method = DELETE
	k.URL = targetURL
	k.Errors = nil
}
973311
func (wh *Webhook) Delete(client *messagebird.Client) error {
	return client.Request(nil, http.MethodDelete, apiRoot+"/webhooks/"+wh.ID, nil)
}
140143
func (g *routeGroup) Delete(path string, h http.HandlerFunc) {
	g.handle(http.MethodDelete, path, h)
}
1263018
func (r *Route) Delete(fn http.HandlerFunc) *Route {
	return r.Method(http.MethodDelete, fn)
}
145981
func (p *RequestParams) Delete(params ...string) (err error) {
	if p == nil {
		return
	}
	for _, param := range params {
		if err = p.delete(param); err != nil {
			return
		}
	}
	return
}
517115
func (c *Client) Delete(u string) (*roundtrip.Response, error) {
	return httplib.ConvertResponse(c.Client.Delete(context.TODO(), u))
}
421752
func (a *Application) Delete() (*Application, *http.Response, []error) {
	k := kumoru.New()

	k.Delete(fmt.Sprintf("%s/v1/applications/%s", k.EndPoint.Application, a.UUID))
	k.SignRequest(true)

	resp, _, errs := k.End()

	if len(errs) > 0 {
		return a, resp, errs
	}

	if resp.StatusCode >= 400 {
		errs = append(errs, fmt.Errorf("%s", resp.Status))
	}

	return a, resp, nil
}
1369576
func (callflow *CallFlow) Delete(client *messagebird.Client) error {
	return client.Request(nil, http.MethodDelete, apiRoot+"/call-flows/"+callflow.ID, nil)
}
1075456
func (r *Router) Delete(pattern string, handlers ...Middleware) *Router {
	return r.Handle(http.MethodDelete, pattern, handlers...)
}
534999
func (s *ServicesService) Delete(idOrName string) (*http.Response, error) {
	return s.DeleteWithContext(context.TODO(), idOrName)
}
362492
func (s *Sling) Delete(pathURL string) *Sling {
	s.method = "DELETE"
	return s.Path(pathURL)
}