https://developer.zendesk.com/rest_api/docs/core/ticket_fields#delete-ticket-field
508959
def ticket_field_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/ticket_fields/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
1269910
def delete_field(order)
      if @fields[order]
        raise JSS::MissingDataError, "Fields can't be empty" if @fields.count == 1
        @fields.delete_at index
        order_fields
        @need_to_update = true
      end
    end
1286508
def ticket_forms_reorder(self, data, **kwargs):
        ""
        api_path = "/api/v2/ticket_forms/reorder.json"
        return self.call(api_path, method="PUT", data=data, **kwargs)
679187
public long delete(final List<TicketDocument> ticketDocuments) {
        return (long) db.executeBulk(ticketDocuments.stream().map(BulkDeleteDocument::of)
            .collect(Collectors.toList())).size();
    }
7165
def user_field_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/user_fields/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
372207
def delete(self, **kwargs):
        
        response = self._requester.request(
            'DELETE',
            'calendar_events/{}'.format(self.id),
            _kwargs=combine_kwargs(**kwargs)
        )
        return CalendarEvent(self._requester, response.json())
1036674
public void deleteCustomField(String accountId, String customFieldId, AccountsApi.DeleteCustomFieldOptions options) throws ApiException {
    Object localVarPostBody = "{}";
    
      // verify the required parameter 'accountId' is set
      if (accountId == null) {
      throw new ApiException(400, "Missing the required parameter 'accountId' when calling deleteCustomField");
      }
    
      // verify the required parameter 'customFieldId' is set
      if (customFieldId == null) {
      throw new ApiException(400, "Missing the required parameter 'customFieldId' when calling deleteCustomField");
      }
    
    // create path and map variables
    String localVarPath = "/v2/accounts/{accountId}/custom_fields/{customFieldId}".replaceAll("\\{format\\}","json")
      .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
      .replaceAll("\\{" + "customFieldId" + "\\}", apiClient.escapeString(customFieldId.toString()));

    // query params
    java.util.List<Pair> localVarQueryParams = new java.util.ArrayList<Pair>();
    java.util.Map<String, String> localVarHeaderParams = new java.util.HashMap<String, String>();
    java.util.Map<String, Object> localVarFormParams = new java.util.HashMap<String, Object>();

    if (options != null) {
       localVarQueryParams.addAll(apiClient.parameterToPairs("", "apply_to_templates", options.applyToTemplates));
    }
    
    
      final String[] localVarAccepts = {
    "application/json"
      };
      final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

      final String[] localVarContentTypes = {
    
      };
      final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

      String[] localVarAuthNames = new String[] { "docusignAccessCode" }; //{  };


      apiClient.invokeAPI(localVarPath, "DELETE", localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, null);
      }
767175
def zapier_cancel_hook(request):
    '''
    
    '''
    if request.META.get('HTTP_X_ZAPIER_SECRET', None) != settings.WAFER_TICKETS_SECRET:
        raise PermissionDenied('Incorrect secret')

    # This is required for python 3, and in theory fine on python 2
    payload = json.loads(request.body.decode('utf8'))
    ticket = Ticket.objects.filter(barcode=payload['barcode'])
    if ticket.exists():
        # delete the ticket
        ticket.delete()
    return HttpResponse("Cancelled\n", content_type='text/plain')
1081916
def suspended_ticket_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/suspended_tickets/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
1308954
def delete(self):
        '''  '''
        redis = type(self).get_redis()

        for fieldname, field in self.proxy:
            field.delete(redis)

        redis.delete(self.key())
        redis.srem(type(self).members_key(), self.id)

        if isinstance(self, PermissionHolder):
            redis.delete(self.allow_key())

        if self.notify:
            data = json.dumps({
                'event': 'delete',
                'data': self.to_json(),
            })
            redis.publish(type(self).cls_key(), data)
            redis.publish(self.key(), data)

        return self
371932
async def delete(self, _id=None):
		
		if not _id:
			return {"error":400, 
					"reason":"Missed required fields"}

		document = await self.collection.find_one({"id": _id})

		if not document:
			return {"error":404, 
					"reason":"Not found"}

		deleted_count = await self.collection.delete_one(
							{"id": _id}).deleted_count

		return deleted_count
127930
def ticket_field_options(self, field_id, **kwargs):
        ""
        api_path = "/api/v2/ticket_fields/{field_id}/options.json"
        api_path = api_path.format(field_id=field_id)
        return self.call(api_path, **kwargs)
731608
def ticket_field_option_show(self, field_id, id, **kwargs):
        ""
        api_path = "/api/v2/ticket_fields/{field_id}/options/{id}.json"
        api_path = api_path.format(field_id=field_id, id=id)
        return self.call(api_path, **kwargs)
896150
public static BaseResult clearTicketCheck(String accessToken, TicketCheck ticketCheck) {
        return clearTicketCheck(accessToken, JsonUtil.toJSONString(ticketCheck));
    }
1107731
def ticket_fields(self):
        
        if self.api and self.ticket_field_ids:
            return self.api._get_ticket_fields(self.ticket_field_ids)
840677
def ticket_macro_apply(self, ticket_id, id, **kwargs):
        ""
        api_path = "/api/v2/tickets/{ticket_id}/macros/{id}/apply.json"
        api_path = api_path.format(ticket_id=ticket_id, id=id)
        return self.call(api_path, **kwargs)
634287
def delete(self, customer_id, token_id, data={}, **kwargs):
        "
        url = "{}/{}/tokens/{}".format(self.base_url, customer_id, token_id)
        return self.delete_url(url, data, **kwargs)