https://developer.zendesk.com/rest_api/docs/core/user_fields#delete-user-field-option
424395
def user_field_option_delete(self, field_id, id, **kwargs):
        ""
        api_path = "/api/v2/user_fields/{field_id}/options/{id}.json"
        api_path = api_path.format(field_id=field_id, id=id)
        return self.call(api_path, method="DELETE", **kwargs)
819338
def delete(options = {})
      options = options.merge(user_name: @name)
      resp = @client.delete_user(options)
      resp.data
    end
1317809
def delete(options = {})
      options = options.merge(layer_id: @id)
      resp = @client.delete_layer(options)
      resp.data
    end
1338536
def organization_field_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/organization_fields/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
346823
def delete_user(user, options={})
      raise 'Error: Param user is nil!' if user.nil?

      url = if user.is_a?(Resource::User)
        url_for_resource(user)
      elsif user.is_a?(String)
        url_for_path(user_path(user))
      else
        raise 'Error: Invalid parameters!'
      end
      begin
        client.delete(url, options) do |response|
          response.code == 200
        end
      rescue => e
        raise e if debug
      end
    end
1249576
def delete_field(self,collection,field_name):
        '''
        
        '''
        if not self.does_field_exist(collection,field_name):
            raise ValueError("Field {} Doesn't Exists in Solr Collection {}".format(field_name,collection))
        else:
            temp = {"delete-field" : { "name":field_name }}
            res, con_info = self.solr.transport.send_request(method='POST',endpoint=self.schema_endpoint,collection=collection, data=json.dumps(temp))
            return res
981310
def UsersDelete (self, user_id):
        
        if self.__SenseApiCall__('/users/{user_id}.json'.format(user_id = user_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
411182
def DeleteUser(self, user_link, options=None):
        
        if options is None:
            options = {}

        path = base.GetPathFromLink(user_link)
        user_id = base.GetResourceIdOrFullNameFromLink(user_link)
        return self.DeleteResource(path,
                                   'users',
                                   user_id,
                                   None,
                                   options)
465696
def delete(options = {})
      options = options.merge(endpoint_arn: @arn)
      resp = @client.delete_endpoint(options)
      resp.data
    end
157420
public void deleteCustomField(String accountId, String customFieldId) throws ApiException {
    deleteCustomField(accountId, customFieldId, null);
  }
368887
def delete_field(self, field_name_or_ref_name, project=None):
        
        route_values = {}
        if project is not None:
            route_values['project'] = self._serialize.url('project', project, 'str')
        if field_name_or_ref_name is not None:
            route_values['fieldNameOrRefName'] = self._serialize.url('field_name_or_ref_name', field_name_or_ref_name, 'str')
        self._send(http_method='DELETE',
                   location_id='b51fd764-e5c2-4b9b-aaf7-3395cf4bdd94',
                   version='5.1-preview.2',
                   route_values=route_values)
848450
def closed(self, user):
        
        decision = False
        for record in self.history:
            # Completely ignore older changes
            if record["when"] < self.options.since.date:
                continue
            # Look for status change to CLOSED (unless already found)
            if not decision and record["when"] < self.options.until.date:
                for change in record["changes"]:
                    if (change["field_name"] == "status"
                            and change["added"] == "CLOSED"
                            and record["who"] in [user.email, user.name]):
                        decision = True
            # Make sure that the bug has not been later moved from CLOSED.
            # (This would mean the bug was not closed for a proper reason.)
            else:
                for change in record["changes"]:
                    if (change["field_name"] == "status"
                            and change["removed"] == "CLOSED"):
                        decision = False
        return decision
329006
def remove_field(self, field_name):
        """"""
        field = self._fields.pop(field_name, None)
        if field is not None and field.default is not None:
            if six.callable(field.default):
                self._default_callables.pop(field.key, None)
            else:
                self._defaults.pop(field.key, None)
1352286
function(options, callback) {
      if(typeof options === 'function') {
        callback = options;
        options = {};
      }
      if(options.items) {
        options.users = options.users || [];
        for(var i = 0; i < options.items.length ; i++){
          options.users.push(options.items[i]._key);
        }
        delete options.items;
      }
      if(options.title) {
        options.label = options.title;
        delete options.title;
      }
      if (!self.context.player || !options.users || options.users.length === 0 ) {
        callback.apply(self);
      } else {
        UT.Expression._callAPI('dialog.users', [options], function(){
          callback.apply(self);
        });
      }
    }
652075
def delete(options = {})
      options = options.merge(
        policy_arn: @arn,
        version_id: @version_id
      )
      resp = @client.delete_policy_version(options)
      resp.data
    end
1288841
def delete(config, username, type):
        """"""
        client = Client()
        client.prepare_connection()
        user_api = API(client)
        user_api.delete(username, type)
600707
def delete(options = {})
      options = options.merge(bucket: @bucket_name)
      resp = @client.delete_bucket_cors(options)
      resp.data
    end