This method deletes the specified domain.

        Required parameters

            domain_id:
                Integer or Domain Name (e.g. domain.com), specifies the domain
                to destroy.
334966
def destroy_domain(self, domain_id):
        
        json = self.request('/domains/%s/destroy' % domain_id, method='GET')
        status = json.get('status')
        return status
906221
def delete_record(self, zone_name, record_id):
        
        self.log.debug('Delete record: zone: %s, id %s', zone_name,
                       record_id)
        self._client.delete(
            '/domain/zone/{}/record/{}'.format(zone_name, record_id))
538375
def domain_name(self, domain_name):
        

        if domain_name is None:
            raise ValueError("Invalid value for `domain_name`, must not be `None`")
        if len(domain_name) > 255:
            raise ValueError("Invalid value for `domain_name`, length must be less than `255`")
        if len(domain_name) < 1:
            raise ValueError("Invalid value for `domain_name`, length must be greater than or equal to `1`")

        self._domain_name = domain_name
547895
def delete(self, space_id):
        

        try:
            self.space_id = space_id
            return super(SpacesProxy, self).delete(space_id)
        finally:
            self.space_id = None
211904
def delete(self, id: int):
        
        assert isinstance(id, int)

        self.open_session()
        to_delete = self.get(id)
        self.session.delete(to_delete)
        self.save()
169594
public static base_response delete(nitro_service client, String hostname) throws Exception {
		dnsaddrec deleteresource = new dnsaddrec();
		deleteresource.hostname = hostname;
		return deleteresource.delete_resource(client);
	}
226480
def delete_ip4(self, id_ip):
        

        if not is_valid_int_param(id_ip):
            raise InvalidParameterError(u'Ipv4 identifier is invalid or was not informed.')

        url = 'ip4/delete/' + str(id_ip) + "/"
        code, xml = self.submit(None, 'DELETE', url)

        return self.response(code, xml)
1227731
def delete(self, vpn_id: int):
        
        vpn = self._get_or_abort(vpn_id)
        session.delete(vpn)
        session.commit()
        return '', 204
747741
def delete(unique_id)
      rsp = post("<delete><id>#{unique_id}</id></delete>")
      success?(rsp.body) or log_error(rsp.body)
    end
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)
987270
def delete(self, resource_id):
        
        resource = self._resource(resource_id)
        error_message = is_valid_method(self.__model__, resource)
        if error_message:
            raise BadRequestException(error_message)
        db.session().delete(resource)
        db.session().commit()
        return self._no_content_response()
1090615
def _request_delete_dns_record_by_id(self, identifier):
        """"""
        return self._request_internal("Delete_DNS_Record",
                                      domain=self.domain,
                                      record={'id': identifier})
1257801
def delete(self, delete_subdomains=False):
        
        self.manager.delete(self, delete_subdomains=delete_subdomains)
861111
def remove_domain_from_fqdn(opts, newid):
    '''
    
    '''
    opt_domain = opts.get('minion_id_remove_domain')
    if opt_domain is True:
        if '.' in newid:
            # Remove any domain
            newid, xdomain = newid.split('.', 1)
            log.debug('Removed any domain (%s) from minion id.', xdomain)
    else:
        # Must be string type
        if newid.upper().endswith('.' + opt_domain.upper()):
            # Remove single domain
            newid = newid[:-len('.' + opt_domain)]
            log.debug('Removed single domain %s from minion id.', opt_domain)
    return newid
607966
public void deleteRedirect(int id) {
        try {
            sqlService.executeUpdate("DELETE FROM " + Constants.DB_TABLE_SERVERS +
                                         " WHERE " + Constants.GENERIC_ID + " = " + id + ";");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
250487
def del_cached_domain(domains):
    '''
    
    '''
    cache = salt.cache.Cache(__opts__, syspaths.CACHE_DIR)
    if isinstance(domains, six.string_types):
        domains = domains.split(',')
    if not isinstance(domains, list):
        raise CommandExecutionError(
            'You must pass in either a string containing one or more domains '
            'separated by commas, or a list of single domain strings'
        )
    success = []
    failed = []
    for domain in domains:
        try:
            cache.flush('venafi/domains', domain)
            success.append(domain)
        except CommandExecutionError:
            failed.append(domain)
    return {'Succeeded': success, 'Failed': failed}
540023
def remove(self):
        
        LOGGER.debug("IPAddress.remove")
        if self.id is None:
            return None
        else:
            params = {
                'id': self.id
            }
            args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}
            response = IPAddressService.requester.call(args)
            if response.rc != 0:
                LOGGER.warning(
                    'IPAddress.remove - Problem while deleting IP Address' + self.ip_address +
                    '. Reason: ' + str(response.response_content) + '-' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                return self
            else:
                return None