Delete an existing responder in server

REST: DELETE /email/domain/delegatedAccount/{email}/responder
@param email [required] Email
349621
public OvhTaskSpecialAccount delegatedAccount_email_responder_DELETE(String email) throws IOException {
		String qPath = "/email/domain/delegatedAccount/{email}/responder";
		StringBuilder sb = path(qPath, email);
		String resp = exec(qPath, "DELETE", sb.toString(), null);
		return convertTo(resp, OvhTaskSpecialAccount.class);
	}
381458
def delete_member(self, user):
        
        if not self.email_enabled:
            raise EmailNotEnabledError("See settings.EMAIL_ENABLED")
        return requests.delete(
            f"{self.api_url}/{self.address}/members/{user.email}",
            auth=("api", self.api_key),
        )
663446
def remove(self, email):
        
        if email in self._collaborators:
            if self._collaborators[email] == ShareRequestValue.Add:
                del self._collaborators[email]
            else:
                self._collaborators[email] = ShareRequestValue.Remove
        self._dirty = True
1087686
def reset_password_email(email, token, root_url)
    @email, @token, @host, @protocol = email, token
    @token = token
    @protocol, @host = *root_url.split('://', 2)
    @host.slice!(-1) if @host[-1] == ?/

    hostname = @host.split(':', 2).first  # Strip out any port.
    mail to: email, from: reset_password_from(token, hostname, @protocol),
         subject: reset_password_subject(token, hostname, @protocol)
  end
367887
@Override
	public void delete(final T entity) {
		String id = null;
		try {
			id = (String) arangoOperations.getConverter().getMappingContext().getPersistentEntity(domainClass)
					.getIdProperty().getField().get(entity);
		} catch (final IllegalAccessException e) {
			e.printStackTrace();
		}
		arangoOperations.delete(id, domainClass);
	}
1097594
@Path("{id}")
  @DELETE
  @Produces(APPLICATION_JSON)
  @Timed
  @ExceptionMetered
  public JobDeleteResponse delete(@PathParam("id") @Valid final JobId id,
                                  @QueryParam("token") @DefaultValue("") final String token) {
    if (!id.isFullyQualified()) {
      throw badRequest("Invalid id");
    }
    try {
      model.removeJob(id, token);
      return new JobDeleteResponse(JobDeleteResponse.Status.OK);
    } catch (JobDoesNotExistException e) {
      throw notFound(new JobDeleteResponse(JobDeleteResponse.Status.JOB_NOT_FOUND));
    } catch (JobStillDeployedException e) {
      throw badRequest(new JobDeleteResponse(JobDeleteResponse.Status.STILL_IN_USE));
    } catch (TokenVerificationException e) {
      throw forbidden(new JobDeleteResponse(JobDeleteResponse.Status.FORBIDDEN));
    }
  }
971985
def remove_from_subscriptions(self, subscription):
        
        assert isinstance(subscription, github.Repository.Repository), subscription
        headers, data = self._requester.requestJsonAndCheck(
            "DELETE",
            "/user/subscriptions/" + subscription._identity
        )
1048071
public void domain_acl_accountId_DELETE(String domain, String accountId) throws IOException {
		String qPath = "/email/domain/{domain}/acl/{accountId}";
		StringBuilder sb = path(qPath, domain, accountId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1267151
function(data) {
      var headers = {
        email: data.email,
        password: data.password,
      };

      var url = 'enrollments/' + data.enrollment;


      return client.request('DELETE', url, headers);
    }
307009
public void deleteServerRegistrationHTTP(RESTRequest request,
                                             int clientID,
                                             ServerNotificationRegistration serverNotificationRegistration,
                                             String registrationID,
                                             JSONConverter converter) {
        //Get the client area
        ClientNotificationArea clientArea = getInboxIfAvailable(clientID, null);

        if (registrationID != null) {
            String[] artifacts = registrationID.split("_");
            int filterID = Integer.parseInt(artifacts[0]);
            int handbackID = Integer.parseInt(artifacts[1]);

            //Since this is not coming from our java client, the registration object will not have any IDs on them. So set the IDs before continuing.
            serverNotificationRegistration.filterID = filterID;
            serverNotificationRegistration.handbackID = handbackID;
        }

        clientArea.removeServerNotificationListener(request, serverNotificationRegistration, serverNotificationRegistration.operation == Operation.RemoveAll, converter,
                                                    true);
    }
723497
private void doRemoveMailServer() throws PageException {
	admin.removeMailServer(getString("admin", action, "hostname"), getString("username", null));
	store();
	adminSync.broadcast(attributes, config);
    }
1119438
function (email) {
  var domain = Accounts._options.restrictCreationByEmailDomain;
  return !domain ||
    (_.isFunction(domain) && domain(email)) ||
    (_.isString(domain) &&
      (new RegExp('@' + quotemeta(domain) + '$', 'i')).test(email));
}
1130068
@DELETE
  @Path("{id}")
  @Produces(APPLICATION_JSON)
  @Timed
  @ExceptionMetered
  public HostDeregisterResponse delete(@PathParam("id") final String host) {
    try {
      model.deregisterHost(host);
      return new HostDeregisterResponse(HostDeregisterResponse.Status.OK, host);
    } catch (HostNotFoundException e) {
      throw notFound(new HostDeregisterResponse(HostDeregisterResponse.Status.NOT_FOUND, host));
    } catch (HostStillInUseException e) {
      throw badRequest(new HostDeregisterResponse(HostDeregisterResponse.Status.JOBS_STILL_DEPLOYED,
          host));
    }
  }
420458
@DELETE
    @Path("{id}")
    public SuccessResponse deleteApiKey(@PathParam("id") String id, @Authenticated Subject subject) {
        _uac.deleteApiKey(subject, id);
        return SuccessResponse.instance();
    }
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;
    }
911808
public void removeSigner(String email) throws HelloSignException {
        if (email == null) {
            throw new HelloSignException("Cannot remove null signer");
        }
        for (int i = 0; i < signers.size(); i++) {
            if (email.equalsIgnoreCase(signers.get(i).getEmail())) {
                signers.remove(i);
            }
        }
    }
1263898
@POST
  @Path("{id}/email")
  @RolesAllowed({"ROLE_ADMIN"})
  public Response changeEmail(@PathParam("id") Long userId, EmailRequest request) {
    checkNotNull(userId);
    checkEmailFormat(request.getEmail());

    boolean isSuccess = userService.changeEmailAddress(userId, request.getEmail());
    return isSuccess ? Response.noContent().build() : Response.status(Response.Status.BAD_REQUEST).build();
  }