Delete an existing mailbox in server

REST: DELETE /email/domain/{domain}/account/{accountName}
@param domain [required] Name of your domain name
@param accountName [required] Name of account
5071
public OvhTaskPop domain_account_accountName_DELETE(String domain, String accountName) throws IOException {
		String qPath = "/email/domain/{domain}/account/{accountName}";
		StringBuilder sb = path(qPath, domain, accountName);
		String resp = exec(qPath, "DELETE", sb.toString(), null);
		return convertTo(resp, OvhTaskPop.class);
	}
271159
public function deleteMailbox($mailboxName)
    {
        $uri = "mailboxes/$mailboxName";
        try {
            $this->client->getEndpoint()->delete($uri);
        } catch (RequestException $e) {
            $this->processRequestException($e);
        }
    }
127559
public void serviceName_owo_field_DELETE(String serviceName, net.minidev.ovh.api.domain.OvhWhoisObfuscatorFieldsEnum field) throws IOException {
		String qPath = "/domain/{serviceName}/owo/{field}";
		StringBuilder sb = path(qPath, serviceName, field);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1256499
protected void dropDomain(final String domainName, final AmazonSimpleDB sdb) {
		try {
			LOGGER.debug("Dropping domain: {}", domainName);
			DeleteDomainRequest request = new DeleteDomainRequest(domainName);
			sdb.deleteDomain(request);
			LOGGER.debug("Dropped domain: {}", domainName);
		} catch(AmazonClientException amazonException) {
			throw SimpleDbExceptionTranslator.getTranslatorInstance().translateAmazonClientException(amazonException);
		}
	}
1186659
public boolean delete(String name, boolean bankAccount) {
        boolean result = false;
        if (exist(name, bankAccount)) {
            result = Common.getInstance().getStorageHandler().getStorageEngine().deleteAccount(name, bankAccount);
            if (bankAccount) {
                bankList.remove(name);
            } else {
                accountList.remove(name);
            }
        }
        return result;
    }
537895
public function remove(AccountType $accountType): bool
    {
        if (empty($accountType->email)) {
            return false;
        }

        $uri = sprintf(
            '%s/accounts/%s/',
            $this->clipUri($this->client->getConfig('base_uri')),
            $accountType->email
        );

        return $this->client->delete($uri)->getStatusCode() === 200;
    }
1136834
@UpdateHandler(name = "delete_token_account", file = "CouchDbOneTimeTokenAccount_delete.js")
    public void deleteTokenAccount(final CouchDbGoogleAuthenticatorAccount token) {
        db.callUpdateHandler(stdDesignDocumentId, "delete_token_account", token.getCid(), null);
    }
735906
public void releaseMailAccountForThread(final MailAccount account) {
		log.info("Releasing mail account for the current thread: {}", account);
		lock.lock();
		try {
			ThreadReservationKeyWrapper wrapper = usedAccounts.get(account);
			if (wrapper != null) {
				if (wrapper.thread == Thread.currentThread()) {
					log.debug("Releasing mail account: {}", account);
					usedAccounts.remove(account);
					condition.signalAll();
				} else {
					log.warn("Cannot release a mail account reserved by a different thread: {}", account);
				}
			}
		} finally {
			lock.unlock();
		}
	}
1235856
def delete(self, accountId):
        """"""
        acct = BaseAccount.get(accountId)
        if not acct:
            raise Exception('No such account found')

        acct.delete()
        auditlog(event='account.delete', actor=session['user'].username, data={'accountId': accountId})

        return self.make_response('Account deleted')
498169
public OvhFilter domain_account_accountName_filter_name_GET(String domain, String accountName, String name) throws IOException {
		String qPath = "/email/domain/{domain}/account/{accountName}/filter/{name}";
		StringBuilder sb = path(qPath, domain, accountName, name);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhFilter.class);
	}
708288
def _delete_account(self, username):
        

        # account deleted

        ds_user = self.get_user(username)
        if ds_user is not None:
            self._call(["delete", "user", "name=%s" % username])

        return
479276
public void removeAccount(Account accountToDelete) {
        // Thou shalt not delete root
        if (accountToDelete.getId().equals(rootAccount.getId()))
            return;

        Account parent = findParent(accountToDelete);
        if (parent != null) {
            removeAccount(parent, accountToDelete);
            setDirty(true);
        }
    }
188949
public void deleteServer(final de.uniulm.omi.cloudiator.flexiant.client.domain.Server server)
        throws FlexiantException {
        this.deleteServer(server.getId());
    }
563553
public void deleteStream(String domain, String app, String stream) {
        DeleteStreamRequest request = new DeleteStreamRequest()
                .withDomain(domain)
                .withApp(app)
                .withStream(stream);
        deleteStream(request);
    }
21795
public void zone_zoneName_dynHost_login_login_DELETE(String zoneName, String login) throws IOException {
		String qPath = "/domain/zone/{zoneName}/dynHost/login/{login}";
		StringBuilder sb = path(qPath, zoneName, login);
		exec(qPath, "DELETE", sb.toString(), null);
	}
705075
public function deleteMailbox(MailboxInterface $mailbox): void
    {
        if (false === \imap_deletemailbox($this->resource->getStream(), $mailbox->getFullEncodedName())) {
            throw new DeleteMailboxException(\sprintf('Mailbox "%s" could not be deleted', $mailbox->getName()));
        }

        $this->mailboxes = $this->mailboxNames = null;
        $this->resource->clearLastMailboxUsedCache();
    }
660593
public OvhDomainUsageAccountStruct domain_account_accountName_usage_GET(String domain, String accountName) throws IOException {
		String qPath = "/email/domain/{domain}/account/{accountName}/usage";
		StringBuilder sb = path(qPath, domain, accountName);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhDomainUsageAccountStruct.class);
	}