Delete a volume snapshot

REST: DELETE /cloud/project/{serviceName}/volume/snapshot/{snapshotId}
@param serviceName [required] Project id
@param snapshotId [required] Snapshot id
186679
public void project_serviceName_volume_snapshot_snapshotId_DELETE(String serviceName, String snapshotId) throws IOException {
		String qPath = "/cloud/project/{serviceName}/volume/snapshot/{snapshotId}";
		StringBuilder sb = path(qPath, serviceName, snapshotId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
827033
public void delete(String bucketName, List<KeyVersion> objects) {
        ReactiveSeq.fromList(objects)
                   .grouped(1000)
                   .forEach(l -> {
                       DeleteObjectsRequest req = new DeleteObjectsRequest(
                                                                           bucketName);
                       req.setKeys(l.toList());
                       client.deleteObjects(req);
                   });
    }
906516
public void serviceName_publiccloud_node_nodeId_DELETE(String serviceName, String nodeId) throws IOException {
		String qPath = "/kube/{serviceName}/publiccloud/node/{nodeId}";
		StringBuilder sb = path(qPath, serviceName, nodeId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
692671
public Observable<ServiceResponse<Void>> deleteProjectWithServiceResponseAsync(UUID projectId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.deleteProject(projectId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteProjectDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1252833
def delete_volume(self, volume_name: str):
        
        # Raise an exception if we are not a manager
        if not self._manager:
            raise RuntimeError('Volumes can only be deleted '
                               'on swarm manager nodes')

        # Remove volume
        self._api_client.remove_volume(volume_name)
623625
@Override
    @Transactional
    public void deleteSnapshot(String snapshotId) {
        //delete the snapshot
        snapshotContentItemRepo.deleteBySnapshotName(snapshotId);
        snapshotRepo.deleteByName(snapshotId);
        log.info("successfully deleted snapshot: {}", snapshotId);
    }
712327
func (s *OsdCsiServer) DeleteSnapshot(
	ctx context.Context,
	req *csi.DeleteSnapshotRequest,
) (*csi.DeleteSnapshotResponse, error) {

	if len(req.GetSnapshotId()) == 0 {
		return nil, status.Error(codes.InvalidArgument, "Snapshot id must be provided")
	}

	// If the snapshot is not found, then we can return OK
	volumes, err := s.driver.Inspect([]string{req.GetSnapshotId()})
	if (err == nil && len(volumes) == 0) ||
		(err != nil && err == kvdb.ErrNotFound) {
		return &csi.DeleteSnapshotResponse{}, nil
	} else if err != nil {
		return nil, err
	}

	err = s.driver.Delete(req.GetSnapshotId())
	if err != nil {
		return nil, status.Errorf(codes.Internal, "Unable to delete snapshot %s: %v",
			req.GetSnapshotId(),
			err)
	}

	return &csi.DeleteSnapshotResponse{}, nil
}
29254
public void serviceName_option_option_DELETE(String serviceName, net.minidev.ovh.api.dedicated.server.OvhOptionEnum option) throws IOException {
		String qPath = "/dedicated/server/{serviceName}/option/{option}";
		StringBuilder sb = path(qPath, serviceName, option);
		exec(qPath, "DELETE", sb.toString(), null);
	}
43209
public void project_serviceName_storage_containerId_cors_DELETE(String serviceName, String containerId, String origin) throws IOException {
		String qPath = "/cloud/project/{serviceName}/storage/{containerId}/cors";
		StringBuilder sb = path(qPath, serviceName, containerId);
		query(sb, "origin", origin);
		exec(qPath, "DELETE", sb.toString(), null);
	}
259301
public void serviceName_users_login_DELETE(String serviceName, String login) throws IOException {
		String qPath = "/sms/{serviceName}/users/{login}";
		StringBuilder sb = path(qPath, serviceName, login);
		exec(qPath, "DELETE", sb.toString(), null);
	}
839629
public void serviceName_namespaces_namespaceId_DELETE(String serviceName, String namespaceId) throws IOException {
		String qPath = "/caas/registry/{serviceName}/namespaces/{namespaceId}";
		StringBuilder sb = path(qPath, serviceName, namespaceId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
725228
public Observable<ServiceResponse<Void>> deleteIterationWithServiceResponseAsync(UUID projectId, UUID iterationId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (iterationId == null) {
            throw new IllegalArgumentException("Parameter iterationId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.deleteIteration(projectId, iterationId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteIterationDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
858072
@Help(help = "Delete the VirtualNetworkFunctionRecord of NetworkServiceRecord with specific id")
  public void deleteVirtualNetworkFunctionRecord(final String id, final String idVnfr)
      throws SDKException {
    String url = id + "/vnfrecords" + "/" + idVnfr;
    requestDelete(url);
  }
170957
private void deletePubsubSubscription(String subscription) throws IOException {
    if (pubsubClient == null) {
      pubsubClient = newPubsubClient(options.as(PubsubOptions.class)).build();
    }
    if (executeNullIfNotFound(pubsubClient.projects().subscriptions().get(subscription)) != null) {
      pubsubClient.projects().subscriptions().delete(subscription).execute();
    }
  }
1244172
public void deleteVoiceCall(final String id) throws NotFoundException, GeneralException, UnauthorizedException {
        if (id == null) {
            throw new IllegalArgumentException("Voice Message ID must be specified.");
        }

        String url = String.format("%s%s", VOICE_CALLS_BASE_URL, VOICECALLSPATH);
        messageBirdService.deleteByID(url, id);
    }
197530
public JSONObject deleteByContract(String contractId, String ts) throws JSONException {
        return oClient.delete("/team/v3/snapshots/contracts/" + contractId + "/" + ts);
    }
258130
def delete_volume(name)
      volume = get_volume(name)
      if !volume || !volume['id'] then
        puts "\nError: Volume '#{name}' does not exist"
        exit 1
      end

      params = {
          'command' => 'deleteVolume',
          'id' => volume['id']
      }

      json = send_request(params)
      json['success']
    end