Deletes an Image.

 @param resource_group_name [String] The name of the resource group.
 @param image_name [String] The name of the image.
 @param custom_headers [Hash{String => String}] A hash of custom headers that
 will be added to the HTTP request.
765019
def delete(resource_group_name, image_name, custom_headers:nil)
      response = delete_async(resource_group_name, image_name, custom_headers:custom_headers).value!
      nil
    end
432861
public static xen_nsvpx_image delete(nitro_service client, xen_nsvpx_image resource) throws Exception
	{
		resource.validate("delete");
		return ((xen_nsvpx_image[]) resource.delete_resource(client))[0];
	}
1111629
def remove_security_group(self, name):
        
        for group in self.security_groups:
            if group.isc_name == name:
                group.delete()
1178464
def image_meta_delete(self,
                          image_id=None,     # pylint: disable=C0103
                          name=None,
                          keys=None):
        '''
        
        '''
        nt_ks = self.compute_conn
        if name:
            for image in nt_ks.images.list():
                if image.name == name:
                    image_id = image.id  # pylint: disable=C0103
        pairs = keys.split(',')
        if not image_id:
            return {'Error': 'A valid image name or id was not specified'}
        nt_ks.images.delete_meta(image_id, pairs)
        return {image_id: 'Deleted: {0}'.format(pairs)}
1120156
public static base_response delete(nitro_service client, String ciphergroupname) throws Exception {
		sslcipher deleteresource = new sslcipher();
		deleteresource.ciphergroupname = ciphergroupname;
		return deleteresource.delete_resource(client);
	}
463463
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
    '''
    

    '''
    resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
    if resource:
        if __opts__['test']:
            return 'would delete'
        # flush the resource_cache, because we're modifying a resource
        del __context__['pagerduty_util.resource_cache'][resource_name]
        resource_id = _get_resource_id(resource)
        return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
    else:
        return True
80826
public static ns_doc_image delete(nitro_service client, ns_doc_image resource) throws Exception
	{
		resource.validate("delete");
		return ((ns_doc_image[]) resource.delete_resource(client))[0];
	}
889832
def delete(self, image_file, delete_thumbnails=True):
        
        if delete_thumbnails:
            self.delete_thumbnails(image_file)
        self._delete(image_file.key)
1037601
function(image, callback) {
        var self = this,
            imageId = image instanceof rackspace.Image ? image.id : image;

        var destroyOptions = {
            method: 'DELETE',
            uri: '/images/' + imageId
        };

        self.authorizedRequest(destroyOptions, function(err, res, body) {
            if (err || res.statusCode !== 204) {
                callback(err);
                return;
            }

            callback(err, true);
        });
    }
1337795
def deletegroup(self, group_id):
        
        request = requests.delete(
            '{0}/{1}'.format(self.groups_url, group_id),
            headers=self.headers, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        return request.status_code == 200
545296
public void deleteGroup(String key, IPerson deleter) {

        if (!canDeleteGroup(deleter, key)) {
            throw new RuntimeAuthorizationException(
                    deleter, IPermission.DELETE_GROUP_ACTIVITY, key);
        }

        log.info("Deleting group with key " + key);

        // find the current version of this group entity
        IEntityGroup group = GroupService.findGroup(key);

        // remove this group from the membership list of any current parent
        // groups
        for (IEntityGroup parent : group.getParentGroups()) {
            parent.removeChild(group);
            parent.updateMembers();
        }

        // delete the group
        group.delete();
    }
667257
def delete(self, *args, **kwargs):
        
        try:
            os.remove(self.file.file.name)
        # image does not exist
        except (OSError, IOError):
            pass
        super(Image, self).delete(*args, **kwargs)
708784
def delete_service(resource_root, name, cluster_name="default"):
  
  return call(resource_root.delete,
      "%s/%s" % (SERVICES_PATH % (cluster_name,), name),
      ApiService)
9526
def delete_image_regions(project_id, region_ids, custom_headers:nil)
      response = delete_image_regions_async(project_id, region_ids, custom_headers:custom_headers).value!
      nil
    end
981127
public static xen_sf_storagecentervpx_image delete(nitro_service client, xen_sf_storagecentervpx_image resource) throws Exception
	{
		resource.validate("delete");
		return ((xen_sf_storagecentervpx_image[]) resource.delete_resource(client))[0];
	}
974657
public static base_response delete(nitro_service client, String groupname) throws Exception {
		systemgroup deleteresource = new systemgroup();
		deleteresource.groupname = groupname;
		return deleteresource.delete_resource(client);
	}
64476
def delete_image(self, name: str) -> None:
        
        logger.debug("deleting Docker image: %s", name)
        path = "docker/images/{}".format(name)
        response = self.__api.delete(path)
        if response.status_code != 204:
            try:
                self.__api.handle_erroneous_response(response)
            except Exception:
                logger.exception("failed to delete Docker image: %s", name)
                raise
        else:
            logger.info("deleted Docker image: %s", name)