org.jclouds.azurecompute.arm.features

Interface VaultApi

@Consumes(value="application/json")
public interface VaultApi

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	VaultApi.PrependSlashOrEmptyString

Field Summary

Fields

Modifier and Type	Field and Description
static String	VAULT_API_CHINA_ENDPOINT
static String	VAULT_API_STANDARD_ENDPOINT

Method Summary

Modifier and Type	Method and Description
String	backupKey(URI vaultBaseUrl, String keyName)
String	backupSecret(URI vaultBaseUrl, String secretName)
Certificate.CertificateOperation	createCertificate(URI vaultBaseUrl, String certificateName, Certificate.CertificateAttributes attributes, Certificate.CertificatePolicy policy, Map<String,String> tags)
Key.KeyBundle	createKey(URI vaultBaseUrl, String keyName, Key.KeyAttributes attributes, String curveName, List<String> keyOps, int keySize, String keyType, Map<String,String> tags)
Vault	createOrUpdateVault(String vaultName, String location, VaultProperties properties, Map<String,String> tags)
Key.KeyOperationResult	decrypt(URI vaultBaseUrl, String keyName, String keyVersion, String algorithm, String value)
Certificate.DeletedCertificateBundle	deleteCertificate(URI vaultBaseUrl, String certificateName)
Certificate.Contacts	deleteCertificateContacts(URI vaultBaseUrl)
Certificate.IssuerBundle	deleteCertificateIssuer(URI vaultBaseUrl, String issuerName)
Certificate.CertificateOperation	deleteCertificateOperation(URI vaultBaseUrl, String certificateName)
Key.DeletedKeyBundle	deleteKey(URI vaultBaseUrl, String keyName)
Secret.DeletedSecretBundle	deleteSecret(URI vaultBaseUrl, String secretName)
boolean	deleteVault(String vaultName)
Key.KeyOperationResult	encrypt(URI vaultBaseUrl, String keyName, String keyVersion, String algorithm, String value)
Certificate.CertificateBundle	getCertificate(URI vaultBaseUrl, String certificateName, String certificateVersion)
Certificate.Contacts	getCertificateContacts(URI vaultBaseUrl)
Certificate.IssuerBundle	getCertificateIssuer(URI vaultBaseUrl, String issuerName)
List<Certificate.CertificateIssuer>	getCertificateIssuers(URI vaultBaseUrl)
Certificate.CertificateOperation	getCertificateOperation(URI vaultBaseUrl, String certificateName)
Certificate.CertificatePolicy	getCertificatePolicy(URI vaultBaseUrl, String certificateName)
List<Certificate>	getCertificates(URI vaultBaseUrl)
List<Certificate>	getCertificateVersions(URI vaultBaseUrl, String certificateName)
Certificate.DeletedCertificateBundle	getDeletedCertificate(URI vaultBaseUrl, String certificateName)
List<Certificate.DeletedCertificate>	getDeletedCertificates(URI vaultBaseUrl)
Key.DeletedKeyBundle	getDeletedKey(URI vaultBaseUrl, String keyName)
Secret.DeletedSecretBundle	getDeletedSecret(URI vaultBaseUrl, String secretName)
Vault.DeletedVault	getDeletedVault(String location, String vaultName)
Key.KeyBundle	getKey(URI vaultBaseUrl, String keyName)
List<Key>	getKeyVersions(URI vaultBaseUrl, String keyName)
Secret.SecretBundle	getSecret(URI vaultBaseUrl, String secretName, String secretVersion)
List<Secret>	getSecretVersions(URI vaultBaseUrl, String secretName)
Vault	getVault(String vaultName)
Certificate.CertificateBundle	importCertificate(URI vaultBaseUrl, String certificateName, Certificate.CertificateAttributes attributes, Certificate.CertificatePolicy policy, String password, Map<String,String> tags, String value)
Key.KeyBundle	importKey(URI vaultBaseUrl, String keyName, boolean hsm, Key.KeyAttributes attributes, Key.JsonWebKey key, Map<String,String> tags)
List<Key.DeletedKeyBundle>	listDeletedKeys(URI vaultBaseUrl)
List<Secret.DeletedSecretBundle>	listDeletedSecrets(URI vaultBaseUrl)
List<Vault.DeletedVault>	listDeletedVaults()
List<Key>	listKeys(URI keyVaultUri)
List<Secret>	listSecrets(URI keyVaultUri)
List<Vault>	listVaults()
Certificate.CertificateBundle	mergeCertificate(URI vaultBaseUrl, String certificateName, Certificate.CertificateAttributes attributes, Map<String,String> tags, List<String> value)
boolean	purgeDeletedCertificate(URI vaultBaseUrl, String certificateName)
boolean	purgeDeletedKey(URI vaultBaseUrl, String keyName)
boolean	purgeDeletedSecret(URI vaultBaseUrl, String secretName)
boolean	purgeVault(String location, String vaultName)
Certificate.CertificateBundle	recoverDeletedCertificate(URI vaultBaseUrl, String certificateName)
Key.KeyBundle	recoverDeletedKey(URI vaultBaseUrl, String keyName)
Secret.SecretBundle	recoverDeletedSecret(URI vaultBaseUrl, String secretName)
Key.KeyBundle	restoreKey(URI vaultBaseUrl, String keyInfo)
Secret.SecretBundle	restoreSecret(URI vaultBaseUrl, String secretInfo)
Certificate.Contacts	setCertificateContacts(URI vaultBaseUrl, List<Certificate.Contact> contacts)
Certificate.IssuerBundle	setCertificateIssuer(URI vaultBaseUrl, String issuerName, Certificate.IssuerAttributes attributes, Certificate.IssuerCredentials credentials, Certificate.OrganizationDetails orgDetails, String provider)
Secret.SecretBundle	setSecret(URI keyVaultUri, String secretName, Secret.SecretAttributes attributes, String contentType, Map<String,String> tags, String value)
Key.KeyOperationResult	sign(URI vaultBaseUrl, String keyName, String keyVersion, String algorithm, String value)
Key.KeyOperationResult	unwrap(URI vaultBaseUrl, String keyName, String keyVersion, String algorithm, String value)
Certificate.CertificateBundle	updateCertificate(URI vaultBaseUrl, String certificateName, String certificateVersion, Certificate.CertificateAttributes attributes, Certificate.CertificatePolicy policy, Map<String,String> tags)
Certificate.IssuerBundle	updateCertificateIssuer(URI vaultBaseUrl, String issuerName, Certificate.IssuerAttributes attributes, Certificate.IssuerCredentials credentials, Certificate.OrganizationDetails orgDetails, String provider)
Certificate.CertificateOperation	updateCertificateOperation(URI vaultBaseUrl, String certificateName, boolean cancellationRequested)
Certificate.CertificatePolicy	updateCertificatePolicy(URI vaultBaseUrl, String certificateName, Certificate.CertificateAttributes attributes, Certificate.IssuerParameters issuer, Certificate.KeyProperties keyProps, List<Certificate.LifetimeAction> lifetimeActions, Certificate.SecretProperties secretProps, Certificate.X509CertificateProperties x509Props)
Key.KeyBundle	updateKey(URI vaultBaseUrl, String keyName, String keyVersion, Key.KeyAttributes attributes, List<String> keyOps, Map<String,String> tags)
Secret.SecretBundle	updateSecret(URI vaultBaseUrl, String secretName, String secretVersion, Secret.SecretAttributes attributes, String contentType, Map<String,String> tags)
boolean	verify(URI vaultBaseUrl, String keyName, String keyVersion, String algorithm, String digest, String value)
Key.KeyOperationResult	wrap(URI vaultBaseUrl, String keyName, String keyVersion, String algorithm, String value)

Field Detail

VAULT_API_STANDARD_ENDPOINT

static final String VAULT_API_STANDARD_ENDPOINT

See Also:

Constant Field Values

VAULT_API_CHINA_ENDPOINT

static final String VAULT_API_CHINA_ENDPOINT

See Also:

Constant Field Values

Method Detail

listVaults

@Named(value="vault:list")
 @GET
 @Path(value="/resourcegroups/{resourcegroup}/providers/Microsoft.KeyVault/vaults")
List<Vault> listVaults()

createOrUpdateVault

@Named(value="vault:create_or_update")
 @PUT
 @Path(value="/resourcegroups/{resourcegroup}/providers/Microsoft.KeyVault/vaults/{vaultName}")
Vault createOrUpdateVault(@PathParam(value="vaultName")
                                                                                                                                                                       String vaultName,
                                                                                                                                                                       String location,
                                                                                                                                                                       VaultProperties properties,
                                                                                                                                                                       @Nullable
                                                                                                                                                                       Map<String,String> tags)

getVault

@Named(value="vault:get")
 @Path(value="/resourcegroups/{resourcegroup}/providers/Microsoft.KeyVault/vaults/{vaultName}")
 @GET
Vault getVault(@PathParam(value="vaultName")
                                                                                                                                               String vaultName)

deleteVault

@Named(value="vault:delete")
 @Path(value="/resourcegroups/{resourcegroup}/providers/Microsoft.KeyVault/vaults/{vaultName}")
 @DELETE
boolean deleteVault(@PathParam(value="vaultName")
                                                                                                                                                          String vaultName)

listDeletedVaults

@Named(value="vault:list_deleted_vaults")
 @Path(value="/providers/Microsoft.KeyVault/deletedVaults")
 @GET
List<Vault.DeletedVault> listDeletedVaults()

getDeletedVault

@Named(value="vault:get_deleted")
 @GET
 @Path(value="/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}")
Vault.DeletedVault getDeletedVault(@PathParam(value="location")
                                                                                                                                                                        String location,
                                                                                                                                                                        @PathParam(value="vaultName")
                                                                                                                                                                        String vaultName)

purgeVault

@Named(value="vault:purge")
 @POST
 @Path(value="/providers/Microsoft.KeyVault/locations/{location}/deletedVaults/{vaultName}/purge")
boolean purgeVault(@PathParam(value="location")
                                                                                                                                                         String location,
                                                                                                                                                         @PathParam(value="vaultName")
                                                                                                                                                         String vaultName)

listKeys

@Named(value="key:list")
 @GET
 @Path(value="/keys")
List<Key> listKeys(URI keyVaultUri)

createKey

@Named(value="key:create")
 @POST
 @Path(value="/keys/{keyName}/create")
Key.KeyBundle createKey(URI vaultBaseUrl,
                                                                                                 @PathParam(value="keyName")
                                                                                                 String keyName,
                                                                                                 @Nullable
                                                                                                 Key.KeyAttributes attributes,
                                                                                                 @Nullable
                                                                                                 String curveName,
                                                                                                 @Nullable
                                                                                                 List<String> keyOps,
                                                                                                 int keySize,
                                                                                                 String keyType,
                                                                                                 @Nullable
                                                                                                 Map<String,String> tags)

importKey

@Named(value="key:import")
 @PUT
 @Path(value="/keys/{keyName}")
Key.KeyBundle importKey(URI vaultBaseUrl,
                                                                                         @PathParam(value="keyName")
                                                                                         String keyName,
                                                                                         boolean hsm,
                                                                                         @Nullable
                                                                                         Key.KeyAttributes attributes,
                                                                                         @Nullable
                                                                                         Key.JsonWebKey key,
                                                                                         @Nullable
                                                                                         Map<String,String> tags)

getKey

@Named(value="key:get")
 @GET
 @Path(value="/keys/{keyName}")
Key.KeyBundle getKey(URI vaultBaseUrl,
                                                                                   @PathParam(value="keyName")
                                                                                   String keyName)

deleteKey

@Named(value="key:delete")
 @DELETE
 @Path(value="/keys/{keyName}")
Key.DeletedKeyBundle deleteKey(URI vaultBaseUrl,
                                                                                                   @PathParam(value="keyName")
                                                                                                   String keyName)

getKeyVersions

@Named(value="key:get_versions")
 @GET
 @Path(value="/keys/{keyName}/versions")
List<Key> getKeyVersions(URI vaultBaseUrl,
                                                                                                         @PathParam(value="keyName")
                                                                                                         String keyName)

updateKey

@Named(value="key:update")
 @Path(value="/keys/{keyName}{keyVersion}")
Key.KeyBundle updateKey(URI vaultBaseUrl,
                                                                                               @PathParam(value="keyName")
                                                                                               String keyName,
                                                                                               @Nullable @PathParam(value="keyVersion")
                                                                                               String keyVersion,
                                                                                               @Nullable
                                                                                               Key.KeyAttributes attributes,
                                                                                               @Nullable
                                                                                               List<String> keyOps,
                                                                                               @Nullable
                                                                                               Map<String,String> tags)

backupKey

@Named(value="key:backup")
 @POST
 @Path(value="/keys/{keyName}/backup")
String backupKey(URI vaultBaseUrl,
                                                                                          @PathParam(value="keyName")
                                                                                          String keyName)

restoreKey

@Named(value="key:restore")
 @POST
 @Path(value="/keys/restore")
Key.KeyBundle restoreKey(URI vaultBaseUrl,
                                                                                          String keyInfo)

listDeletedKeys

@Named(value="key:list_deleted")
 @GET
 @Path(value="/deletedkeys")
List<Key.DeletedKeyBundle> listDeletedKeys(URI vaultBaseUrl)

getDeletedKey

@Named(value="key:get_deleted")
 @GET
 @Path(value="/deletedkeys/{keyName}")
Key.DeletedKeyBundle getDeletedKey(URI vaultBaseUrl,
                                                                                                                @PathParam(value="keyName")
                                                                                                                String keyName)

recoverDeletedKey

@Named(value="key:recover_deleted")
 @POST
 @Path(value="/deletedkeys/{keyName}/recover")
Key.KeyBundle recoverDeletedKey(URI vaultBaseUrl,
                                                                                                                          @PathParam(value="keyName")
                                                                                                                          String keyName)

purgeDeletedKey

@Named(value="key:purge_deleted")
 @DELETE
 @Path(value="/deletedkeys/{keyName}")
boolean purgeDeletedKey(URI vaultBaseUrl,
                                                                                                          @PathParam(value="keyName")
                                                                                                          String keyName)

encrypt

@Named(value="key:crypto_encrypt")
 @POST
 @Path(value="/keys/{keyName}{keyVersion}/encrypt")
Key.KeyOperationResult encrypt(URI vaultBaseUrl,
                                                                                                                             @PathParam(value="keyName")
                                                                                                                             String keyName,
                                                                                                                             @Nullable @PathParam(value="keyVersion")
                                                                                                                             String keyVersion,
                                                                                                                             String algorithm,
                                                                                                                             String value)

decrypt

@Named(value="key:crypto_decrypt")
 @POST
 @Path(value="/keys/{keyName}{keyVersion}/decrypt")
Key.KeyOperationResult decrypt(URI vaultBaseUrl,
                                                                                                                             @PathParam(value="keyName")
                                                                                                                             String keyName,
                                                                                                                             @Nullable @PathParam(value="keyVersion")
                                                                                                                             String keyVersion,
                                                                                                                             String algorithm,
                                                                                                                             String value)

sign

@Named(value="key:crypto_sign")
 @POST
 @Path(value="/keys/{keyName}{keyVersion}/sign")
Key.KeyOperationResult sign(URI vaultBaseUrl,
                                                                                                                    @PathParam(value="keyName")
                                                                                                                    String keyName,
                                                                                                                    @Nullable @PathParam(value="keyVersion")
                                                                                                                    String keyVersion,
                                                                                                                    String algorithm,
                                                                                                                    String value)

verify

@Named(value="key:crypto_verify")
 @POST
 @Path(value="/keys/{keyName}{keyVersion}/verify")
boolean verify(URI vaultBaseUrl,
                                                                                                           @PathParam(value="keyName")
                                                                                                           String keyName,
                                                                                                           @Nullable @PathParam(value="keyVersion")
                                                                                                           String keyVersion,
                                                                                                           String algorithm,
                                                                                                           String digest,
                                                                                                           String value)

wrap

@Named(value="key:crypto_wrap")
 @POST
 @Path(value="/keys/{keyName}{keyVersion}/wrapkey")
Key.KeyOperationResult wrap(URI vaultBaseUrl,
                                                                                                                       @PathParam(value="keyName")
                                                                                                                       String keyName,
                                                                                                                       @Nullable @PathParam(value="keyVersion")
                                                                                                                       String keyVersion,
                                                                                                                       String algorithm,
                                                                                                                       String value)

unwrap

@Named(value="key:crypto_unwrap")
 @POST
 @Path(value="/keys/{keyName}{keyVersion}/unwrapkey")
Key.KeyOperationResult unwrap(URI vaultBaseUrl,
                                                                                                                             @PathParam(value="keyName")
                                                                                                                             String keyName,
                                                                                                                             @Nullable @PathParam(value="keyVersion")
                                                                                                                             String keyVersion,
                                                                                                                             String algorithm,
                                                                                                                             String value)

listSecrets

@Named(value="secret:list")
 @GET
 @Path(value="/secrets")
List<Secret> listSecrets(URI keyVaultUri)

setSecret

@Named(value="secret:set")
 @PUT
 @Path(value="/secrets/{secretName}")
Secret.SecretBundle setSecret(URI keyVaultUri,
                                                                                                     @PathParam(value="secretName")
                                                                                                     String secretName,
                                                                                                     @Nullable
                                                                                                     Secret.SecretAttributes attributes,
                                                                                                     @Nullable
                                                                                                     String contentType,
                                                                                                     @Nullable
                                                                                                     Map<String,String> tags,
                                                                                                     String value)

getSecret

@Named(value="secret:get")
 @GET
 @Path(value="/secrets/{secretName}{secretVersion}")
Secret.SecretBundle getSecret(URI vaultBaseUrl,
                                                                                                                    @PathParam(value="secretName")
                                                                                                                    String secretName,
                                                                                                                    @Nullable @PathParam(value="secretVersion")
                                                                                                                    String secretVersion)

deleteSecret

@Named(value="secret:delete")
 @DELETE
 @Path(value="/secrets/{secretName}")
Secret.DeletedSecretBundle deleteSecret(URI vaultBaseUrl,
                                                                                                                     @PathParam(value="secretName")
                                                                                                                     String secretName)

getSecretVersions

@Named(value="secret:get_versions")
 @GET
 @Path(value="/secrets/{secretName}/versions")
List<Secret> getSecretVersions(URI vaultBaseUrl,
                                                                                                                        @PathParam(value="secretName")
                                                                                                                        String secretName)

updateSecret

@Named(value="secret:update")
 @Path(value="/secrets/{secretName}{secretVersion}")
Secret.SecretBundle updateSecret(URI vaultBaseUrl,
                                                                                                                    @PathParam(value="secretName")
                                                                                                                    String secretName,
                                                                                                                    @Nullable @PathParam(value="secretVersion")
                                                                                                                    String secretVersion,
                                                                                                                    @Nullable
                                                                                                                    Secret.SecretAttributes attributes,
                                                                                                                    @Nullable
                                                                                                                    String contentType,
                                                                                                                    @Nullable
                                                                                                                    Map<String,String> tags)

backupSecret

@Named(value="secret:backup")
 @POST
 @Path(value="/secrets/{secretName}/backup")
String backupSecret(URI vaultBaseUrl,
                                                                                                      @PathParam(value="secretName")
                                                                                                      String secretName)

restoreSecret

@Named(value="secret:restore")
 @POST
 @Path(value="/secrets/restore")
Secret.SecretBundle restoreSecret(URI vaultBaseUrl,
                                                                                                         String secretInfo)

listDeletedSecrets

@Named(value="secret:list_deleted")
 @GET
 @Path(value="/deletedsecrets")
List<Secret.DeletedSecretBundle> listDeletedSecrets(URI vaultBaseUrl)

getDeletedSecret

@Named(value="secret:get_deleted")
 @GET
 @Path(value="/deletedsecrets/{secretName}")
Secret.DeletedSecretBundle getDeletedSecret(URI vaultBaseUrl,
                                                                                                                                  @PathParam(value="secretName")
                                                                                                                                  String secretName)

recoverDeletedSecret

@Named(value="secret:recover_deleted")
 @POST
 @Path(value="/deletedsecrets/{secretName}/recover")
Secret.SecretBundle recoverDeletedSecret(URI vaultBaseUrl,
                                                                                                                                            @PathParam(value="secretName")
                                                                                                                                            String secretName)

purgeDeletedSecret

@Named(value="secret:purge_deleted")
 @DELETE
 @Path(value="/deletedsecrets/{secretName}")
boolean purgeDeletedSecret(URI vaultBaseUrl,
                                                                                                                      @PathParam(value="secretName")
                                                                                                                      String secretName)

createCertificate

@Named(value="certificate:create")
 @POST
 @Path(value="/certificates/{certificateName}/create")
Certificate.CertificateOperation createCertificate(URI vaultBaseUrl,
                                                                                                                                                    @PathParam(value="certificateName")
                                                                                                                                                    String certificateName,
                                                                                                                                                    @Nullable
                                                                                                                                                    Certificate.CertificateAttributes attributes,
                                                                                                                                                    @Nullable
                                                                                                                                                    Certificate.CertificatePolicy policy,
                                                                                                                                                    @Nullable
                                                                                                                                                    Map<String,String> tags)

getCertificate

@Named(value="certificate:get")
 @GET
 @Path(value="/certificates/{certificateName}{certificateVersion}")
Certificate.CertificateBundle getCertificate(URI vaultBaseUrl,
                                                                                                                                                       @PathParam(value="certificateName")
                                                                                                                                                       String certificateName,
                                                                                                                                                       @Nullable @PathParam(value="certificateVersion")
                                                                                                                                                       String certificateVersion)

deleteCertificate

@Named(value="certificate:delete")
 @DELETE
 @Path(value="/certificates/{certificateName}")
Certificate.DeletedCertificateBundle deleteCertificate(URI vaultBaseUrl,
                                                                                                                                                   @PathParam(value="certificateName")
                                                                                                                                                   String certificateName)

getCertificates

@Named(value="certificate:list")
 @GET
 @Path(value="/certificates")
List<Certificate> getCertificates(URI vaultBaseUrl)

getDeletedCertificates

@Named(value="certificate:list_deleted")
 @GET
 @Path(value="/deletedcertificates")
List<Certificate.DeletedCertificate> getDeletedCertificates(URI vaultBaseUrl)

getDeletedCertificate

@Named(value="certificate:get_deleted")
 @GET
 @Path(value="/deletedcertificates/{certificateName}")
Certificate.DeletedCertificateBundle getDeletedCertificate(URI vaultBaseUrl,
                                                                                                                                                                @PathParam(value="certificateName")
                                                                                                                                                                String certificateName)

recoverDeletedCertificate

@Named(value="certificate:recover_deleted")
 @POST
 @Path(value="/deletedcertificates/{certificateName}/recover")
Certificate.CertificateBundle recoverDeletedCertificate(URI vaultBaseUrl,
                                                                                                                                                                          @PathParam(value="certificateName")
                                                                                                                                                                          String certificateName)

purgeDeletedCertificate

@Named(value="certificate:purge_deleted")
 @DELETE
 @Path(value="/deletedcertificates/{certificateName}")
boolean purgeDeletedCertificate(URI vaultBaseUrl,
                                                                                                                                          @PathParam(value="certificateName")
                                                                                                                                          String certificateName)

getCertificateVersions

@Named(value="certificate:get_versions")
 @GET
 @Path(value="/certificates/{certificateName}/versions")
List<Certificate> getCertificateVersions(URI vaultBaseUrl,
                                                                                                                                                 @PathParam(value="certificateName")
                                                                                                                                                 String certificateName)

updateCertificate

@Named(value="certificate:update")
 @Path(value="/certificates/{certificateName}{certificateVersion}")
Certificate.CertificateBundle updateCertificate(URI vaultBaseUrl,
                                                                                                                                                       @PathParam(value="certificateName")
                                                                                                                                                       String certificateName,
                                                                                                                                                       @Nullable @PathParam(value="certificateVersion")
                                                                                                                                                       String certificateVersion,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.CertificateAttributes attributes,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.CertificatePolicy policy,
                                                                                                                                                       @Nullable
                                                                                                                                                       Map<String,String> tags)

importCertificate

@Named(value="certificate:import")
 @POST
 @Path(value="/certificates/{certificateName}/import")
Certificate.CertificateBundle importCertificate(URI vaultBaseUrl,
                                                                                                                                                 @PathParam(value="certificateName")
                                                                                                                                                 String certificateName,
                                                                                                                                                 @Nullable
                                                                                                                                                 Certificate.CertificateAttributes attributes,
                                                                                                                                                 @Nullable
                                                                                                                                                 Certificate.CertificatePolicy policy,
                                                                                                                                                 @Nullable
                                                                                                                                                 String password,
                                                                                                                                                 @Nullable
                                                                                                                                                 Map<String,String> tags,
                                                                                                                                                 String value)

mergeCertificate

@Named(value="certificate:merge")
 @POST
 @Path(value="/certificates/{certificateName}/pending/merge")
Certificate.CertificateBundle mergeCertificate(URI vaultBaseUrl,
                                                                                                                                                      @PathParam(value="certificateName")
                                                                                                                                                      String certificateName,
                                                                                                                                                      @Nullable
                                                                                                                                                      Certificate.CertificateAttributes attributes,
                                                                                                                                                      @Nullable
                                                                                                                                                      Map<String,String> tags,
                                                                                                                                                      List<String> value)

getCertificateOperation

@Named(value="certificate:get_operation")
 @GET
 @Path(value="/certificates/{certificateName}/pending")
Certificate.CertificateOperation getCertificateOperation(URI vaultBaseUrl,
                                                                                                                                                                 @PathParam(value="certificateName")
                                                                                                                                                                 String certificateName)

updateCertificateOperation

@Named(value="certificate:update_operation")
 @Path(value="/certificates/{certificateName}/pending")
Certificate.CertificateOperation updateCertificateOperation(URI vaultBaseUrl,
                                                                                                                                                                 @PathParam(value="certificateName")
                                                                                                                                                                 String certificateName,
                                                                                                                                                                 boolean cancellationRequested)

deleteCertificateOperation

@Named(value="certificate:delete_operation")
 @DELETE
 @Path(value="/certificates/{certificateName}/pending")
Certificate.CertificateOperation deleteCertificateOperation(URI vaultBaseUrl,
                                                                                                                                                                          @PathParam(value="certificateName")
                                                                                                                                                                          String certificateName)

setCertificateIssuer

@Named(value="certificate:set_issuer")
 @PUT
 @Path(value="/certificates/issuers/{issuerName}")
Certificate.IssuerBundle setCertificateIssuer(URI vaultBaseUrl,
                                                                                                                                              @PathParam(value="issuerName")
                                                                                                                                              String issuerName,
                                                                                                                                              @Nullable
                                                                                                                                              Certificate.IssuerAttributes attributes,
                                                                                                                                              @Nullable
                                                                                                                                              Certificate.IssuerCredentials credentials,
                                                                                                                                              @Nullable
                                                                                                                                              Certificate.OrganizationDetails orgDetails,
                                                                                                                                              String provider)

getCertificateIssuers

@Named(value="certificate:get_issuers")
 @GET
 @Path(value="/certificates/issuers")
List<Certificate.CertificateIssuer> getCertificateIssuers(URI vaultBaseUrl)

getCertificateIssuer

@Named(value="certificate:get_issuer")
 @GET
 @Path(value="/certificates/issuers/{issuerName}")
Certificate.IssuerBundle getCertificateIssuer(URI vaultBaseUrl,
                                                                                                                                              @PathParam(value="issuerName")
                                                                                                                                              String issuerName)

updateCertificateIssuer

@Named(value="certificate:update_issuer")
 @Path(value="/certificates/issuers/{issuerName}")
Certificate.IssuerBundle updateCertificateIssuer(URI vaultBaseUrl,
                                                                                                                                              @PathParam(value="issuerName")
                                                                                                                                              String issuerName,
                                                                                                                                              @Nullable
                                                                                                                                              Certificate.IssuerAttributes attributes,
                                                                                                                                              @Nullable
                                                                                                                                              Certificate.IssuerCredentials credentials,
                                                                                                                                              @Nullable
                                                                                                                                              Certificate.OrganizationDetails orgDetails,
                                                                                                                                              String provider)

deleteCertificateIssuer

@Named(value="certificate:delete_issuer")
 @DELETE
 @Path(value="/certificates/issuers/{issuerName}")
Certificate.IssuerBundle deleteCertificateIssuer(URI vaultBaseUrl,
                                                                                                                                                       @PathParam(value="issuerName")
                                                                                                                                                       String issuerName)

getCertificateContacts

@Named(value="certificate:get_contacts")
 @GET
 @Path(value="/certificates/contacts")
Certificate.Contacts getCertificateContacts(URI vaultBaseUrl)

setCertificateContacts

@Named(value="certificate:set_contacts")
 @PUT
 @Path(value="/certificates/contacts")
Certificate.Contacts setCertificateContacts(URI vaultBaseUrl,
                                                                                                                                  List<Certificate.Contact> contacts)

deleteCertificateContacts

@Named(value="certificate:delete_contacts")
 @DELETE
 @Path(value="/certificates/contacts")
Certificate.Contacts deleteCertificateContacts(URI vaultBaseUrl)

getCertificatePolicy

@Named(value="certificate:get_policy")
 @GET
 @Path(value="/certificates/{certificateName}/policy")
Certificate.CertificatePolicy getCertificatePolicy(URI vaultBaseUrl,
                                                                                                                                                       @PathParam(value="certificateName")
                                                                                                                                                       String certificateName)

updateCertificatePolicy

@Named(value="certificate:update_policy")
 @Path(value="/certificates/{certificateName}/policy")
Certificate.CertificatePolicy updateCertificatePolicy(URI vaultBaseUrl,
                                                                                                                                                       @PathParam(value="certificateName")
                                                                                                                                                       String certificateName,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.CertificateAttributes attributes,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.IssuerParameters issuer,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.KeyProperties keyProps,
                                                                                                                                                       @Nullable
                                                                                                                                                       List<Certificate.LifetimeAction> lifetimeActions,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.SecretProperties secretProps,
                                                                                                                                                       @Nullable
                                                                                                                                                       Certificate.X509CertificateProperties x509Props)