DELETE /mailboxes/{mailboxName}
Destroy a mailbox.
171157
public function remove($mailbox = NULL)
        {
            try {

                if (is_null($mailbox))
                    throw new Exception("Mail box name is  not provided or is null", 503);

                $uri    = "/mailboxes/" . $mailbox;
                $result = $this->pestObject->delete($uri);

                return $result;

            } catch (Exception $e) {
                $this->phpariObject->lasterror = $e->getMessage();
                $this->phpariObject->lasttrace = $e->getTraceAsString();

                return FALSE;
            }
        }
236120
public void destroy() {
		clear();
		this.client.operate(null, key, Operation.put(Bin.asNull(binName)));
	}
1200205
def destroy(self, names):
        '''
        
        '''
        mapper = salt.cloud.Map(self._opts_defaults(destroy=True))
        if isinstance(names, six.string_types):
            names = names.split(',')
        return salt.utils.data.simple_types_filter(
            mapper.destroy(names)
        )
322105
function destroy() {
        this._removeEventHandlers();
        this.el.M_Materialbox = undefined;

        // Unwrap image
        $(this.placeholder).after(this.el).remove();

        this.$el.removeAttr('style');
      }
59021
def destroy(update_collection=true)
      parent.with_open_session do |session|
        machine = session.machine
        machine.remove_shared_folder(name)
      end

      # Remove it from it's parent collection
      parent_collection.delete(self, true) if parent_collection && update_collection

      # Mark as a new record so if it is saved again, it will create it
      new_record!
   end
283399
public function deleteMailbox($mbox)
    {
        $mbox = strval($mbox);
        $this->_backend->deleteMailbox($mbox);

        if ($this->_debug) {
            $this->_debug->info(sprintf(
                'CACHE: Deleted mailbox [%s]',
                $mbox
            ));
        }
    }
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
1122752
public function deleteMsgs($mailbox, $uids)
    {
        if (empty($uids)) {
            return;
        }

        $mailbox = strval($mailbox);

        $this->_backend->deleteMsgs($mailbox, $uids);

        if ($this->_debug) {
            $this->_debug->info(sprintf(
                'CACHE: Deleted messages [%s; %s]',
                $mailbox,
                $this->_baseob->getIdsOb($uids)->tostring_sort
            ));
        }
    }
42350
def delete(options = {})
      options = options.merge(
        account_id: @account_id,
        vault_name: @vault_name,
        archive_id: @id
      )
      resp = @client.delete_archive(options)
      resp.data
    end
1081504
def delete(self, event):
        """"""
        assert self.receiver_id == event.receiver_id
        event.response = {'status': 410, 'message': 'Gone.'}
        event.response_code = 410
688169
def delete(self, request, key):
        """"""

        request.DELETE = http.QueryDict(request.body)
        email_addr = request.DELETE.get('email')
        user_id = request.DELETE.get('user')

        if not email_addr:
            return http.HttpResponseBadRequest()

        try:
            email = EmailAddressValidation.objects.get(address=email_addr,
                                                       user_id=user_id)
        except EmailAddressValidation.DoesNotExist:
            pass
        else:
            email.delete()
            return http.HttpResponse(status=204)

        try:
            email = EmailAddress.objects.get(address=email_addr,
                                             user_id=user_id)
        except EmailAddress.DoesNotExist:
            raise http.Http404

        email.user = None
        email.save()
        return http.HttpResponse(status=204)
176659
def delete_all
      start do |pop3|
        unless pop3.mails.empty?
          pop3.delete_all
          pop3.finish
        end
      end
    end
913321
def purge(gandi, email, background, force, alias):
    """"""
    login, domain = email
    if alias:
        if not force:
            proceed = click.confirm('Are you sure to purge all aliases for '
                                    'mailbox %s@%s ?' % (login, domain))
            if not proceed:
                return
        result = gandi.mail.set_alias(domain, login, [])
    else:
        if not force:
            proceed = click.confirm('Are you sure to purge mailbox %s@%s ?'
                                    % (login, domain))
            if not proceed:
                return
        result = gandi.mail.purge(domain, login, background)

    return result
1340586
def delete(self):
        """"""
        params = {"email": self.email_address}
        response = self._delete("/admins.json", params=params)
20466
def destroy(self):
        """"""
        v = vagrant.Vagrant(root=os.getcwd(),
                            quiet_stdout=False,
                            quiet_stderr=True)
        v.destroy()
759398
def delete_box(self, key):
		'''
		'''
		if key:
			uri = self.box_root_uri + '/' + key
			return self._req('delete', uri)
		else:
			return requests.codes.bad_request, None
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();
    }