https://developer.zendesk.com/rest_api/docs/core/user_identities#delete-identity
185805
def user_identity_delete(self, user_id, id, **kwargs):
        ""
        api_path = "/api/v2/users/{user_id}/identities/{id}.json"
        api_path = api_path.format(user_id=user_id, id=id)
        return self.call(api_path, method="DELETE", **kwargs)
970952
def delete(cls, id):
        '''
        
        '''
        client = cls._new_api_client()
        return client.make_request(cls, 'delete', url_params={'id': id})
97628
def clean_out_user(self, name_id):
        

        lid = self.ident.find_local_id(name_id)
        logger.info("Clean out %s", lid)

        # remove the authentications
        try:
            for _nid in [decode(x) for x in self.ident.db[lid].split(" ")]:
                try:
                    self.session_db.remove_authn_statements(_nid)
                except KeyError:
                    pass
        except KeyError:
            pass

        return lid
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)
625029
def delete(*args)
      raise_authentication_error unless authenticated?
      arguments(args, required: [:id])

      delete_request("/authorizations/#{arguments.id}", arguments.params)
    end
406132
@DELETE
  @Path("{user}")
  public Response deleteUser(@PathParam("user") String username, @HeaderParam("Authorization") @DefaultValue("no token") String auth) throws Exception {
    if(!this.isAuth(auth)) {
      throw new Exception("Unauthorized!");
    }
    if( realm != null ){
      AuthenticationManagerRequest req = new AuthenticationManagerRequest();
      req.setAccountName(username);
      req.setRequestType(RequestType.REMOVE);
      
      sendMessage(req);
      return Response.status(Status.GONE).build();
    }
    return Response.status(Status.NOT_FOUND).build();
  }
245796
def GroupsUsersDelete(self, group_id, user_id):
        
        if self.__SenseApiCall__('/groups/{group_id}/users/{user_id}.json'.format(group_id = group_id, user_id = user_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
1286566
def credential_delete(self, *ids):
        
        return self.raw_query("credential", "delete", data={
            "credentials": [{"id": str(id)} for id in ids]
        })
934673
function cleanIdentity(identity) {
  var userPackage = {};
  Object.keys(identity).forEach(function (key) {
    if (key.indexOf('BRIGHTSOCKET:') !== 0) {
      userPackage[key] = identity[key];
    }
  });
  return userPackage;
}
1347648
function deleteAccount (name, cb) {
  assert(this instanceof CouchLogin)
  var u = '/_users/org.couchdb.user:' + name
  this.get(u, thenPut.bind(this))

  function thenPut (er, res, data) {
    if (er || res.statusCode !== 200) {
      return cb(er, res, data)
    }

    // user accts can't be just DELETE'd by non-admins
    // so we take the existing doc and just slap a _deleted
    // flag on it to fake it.  Works the same either way
    // in couch.
    data._deleted = true
    this.put(u + '?rev=' + data._rev, data, cb)
  }
}
965619
def _delete(url, profile):
    ''''''
    request_url = "{0}/api/dashboards/{1}".format(profile.get('grafana_url'),
                                                  url)
    response = requests.delete(
        request_url,
        headers={
            "Accept": "application/json",
            "Authorization": "Bearer {0}".format(profile.get('grafana_token'))
        },
        timeout=profile.get('grafana_timeout'),
    )
    data = response.json()
    return data
1050828
def delete(options = {})
      options = options.merge(
        user_name: @user_name,
        certificate_id: @id
      )
      resp = @client.delete_signing_certificate(options)
      resp.data
    end
1301633
def _api_delete(path, data, server=None):
    '''
    
    '''
    server = _get_server(server)
    response = requests.delete(
            url=_get_url(server['ssl'], server['url'], server['port'], path),
            auth=_get_auth(server['user'], server['password']),
            headers=_get_headers(),
            params=data,
            verify=False
    )
    return _api_response(response)
391302
def delete(params = {})
      case @api.version
      when 'v1'
        response = self.class.post(@api.delete_config[:url],
                                  :query => { :auth_token => @token }.merge(params),
                                  :headers => @api.headers
        )
      when 'v2'
        response = self.class.delete(@api.delete_config[:url],
                                  :query => { :auth_token => @token },
                                  :headers => @api.headers
        )
      end

      ErrorHandler.response_code_to_exception_for :user, user_id, response
      true
    end
1320046
def remove_users_from_organization(self, organization_id, users_list):
        
        log.warning('Removing users...')
        url = 'rest/servicedeskapi/organization/{}/user'.format(organization_id)
        data = {'usernames': users_list}

        return self.delete(url, headers=self.experimental_headers, data=data)
170063
def remove(self, ids, **kwargs):
        
        url = build_uri_with_ids('api/v3/interface/%s/', ids)

        return super(ApiInterfaceRequest, self).delete(self.prepare_url(url, kwargs))
390614
def delete(options = {})
      options = options.merge(
        user_name: @user_name,
        access_key_id: @id
      )
      resp = @client.delete_access_key(options)
      resp.data
    end