This call will delete a user from the Iterable database.  
		This call requires a path parameter to be passed in, 'email'
		in this case, which is why we're just adding this to the 'call'
		argument that goes into the 'api_call' request.
182168
def delete_user_by_email(self, email):
	
		
		call = "/api/users/"+ str(email)

		return self.api_call(call=call, method="DELETE")
903811
def delete(path, body = nil, params = {}, headers = {}, auth = true)
      request(http_method: :delete, path: path, body: body, query: params, headers: headers, auth: auth)
    end
1280913
def delete_user(self, user):
        
        self.service.delete_user(
            user, self.url_prefix, self.auth, self.session, self.session_send_opts)
767005
def delete(self, id, id_name='id', **kwargs):
        
        response = self._new_response()
        if self._check_supported_op('delete', response):
            params = {'Key': {id_name: id}}
            self._call_ddb_method(self.table.delete_item, params, response)
            response.data = 'true'
        response.prepare()
        return response
170744
private <TResponse> void callServiceOwnerDeleteApi(
            String path, Map<String, String> queryParams) throws AuthleteApiException
    {
        callDeleteApi(mServiceOwnerCredentials, path, queryParams);
    }
917406
def delete_user_login(self, id, user_id):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - user_id
        """ID"""
        path["user_id"] = user_id

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        self.logger.debug("DELETE /api/v1/users/{user_id}/logins/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/users/{user_id}/logins/{id}".format(**path), data=data, params=params, no_data=True)
1157903
def delete(path, options={}, format=format)
      respond request(:delete, path, options, format)
    end
371522
def delete(self, data, *args):
        
        path = self.get_resource_name()
        result = self.perform_api_call(self.REST_DELETE, path, data=data)
        return result
930762
def user_sessions_delete(self, user_id, **kwargs):
        ""
        api_path = "/api/v2/users/{user_id}/sessions.json"
        api_path = api_path.format(user_id=user_id)
        return self.call(api_path, method="DELETE", **kwargs)
218459
def c_delete(api, args, verbose=False):
    
    obj = api.get_object(args['<URL>'].split('/')[-1])
    obj.delete()
    if verbose:
        return ['deleted object at', api.url(obj)]
873950
def delete():
    ''''''
    email = click.prompt('Email')
    user = User.objects(email=email).first()
    if not user:
        exit_with_error('Invalid user')
    user.delete()
    success('User deleted successfully')
581065
def delete(callback=None, path=None, method=Method.DELETE, tags=None, summary="Delete specified resource.",
           middleware=None):
    # type: (Callable, Path, Methods, Tags, str, List[Any]) -> Operation
    
    def inner(c):
        op = Operation(c, path or PathParam('{key_field}'), method, None, tags, summary, middleware)
        op.responses.add(Response(HTTPStatus.NO_CONTENT, "{name} has been deleted.", None))
        op.responses.add(Response(HTTPStatus.NOT_FOUND, "Not found", Error))
        return op
    return inner(callback) if callback else inner
535249
def delete(self, callback=None, errback=None):
        
        return self._rest.delete(self.data['id'], callback=callback, errback=errback)
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
983959
def _api_delete(self, api_key=None, **kwargs):
		
		api_key = api_key or self.default_api_key

		return self.api_retrieve(api_key=api_key).delete(**kwargs)
529558
public Request delete() {
        String url = baseUrl
                .newBuilder()
                .addPathSegments("api/v2/emails/provider")
                .build()
                .toString();
        VoidRequest request = new VoidRequest(client, url, "DELETE");
        request.addHeader("Authorization", "Bearer " + apiToken);
        return request;
    }
221112
def users_destroy_many(self, external_ids=None, ids=None, **kwargs):
        ""
        api_path = "/api/v2/users/destroy_many.json"
        api_query = {}
        if "query" in kwargs.keys():
            api_query.update(kwargs["query"])
            del kwargs["query"]
        if external_ids:
            api_query.update({
                "external_ids": external_ids,
            })
        if ids:
            api_query.update({
                "ids": ids,
            })
        return self.call(api_path, query=api_query, method="DELETE", **kwargs)