Package org.jclouds.azurecompute.arm.features

Interface VaultApi

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

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	VaultApi.PrependSlashOrEmptyString

Field Summary

Fields

Modifier and Type	Field	Description
static String	VAULT_API_CHINA_ENDPOINT
static String	VAULT_API_STANDARD_ENDPOINT

Method Summary

Modifier and Type	Method	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("vault:list")
@GET
@Path("/resourcegroups/{resourcegroup}/providers/Microsoft.KeyVault/vaults")
List<Vault> listVaults()

createOrUpdateVault

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

getVault

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

deleteVault

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

listDeletedVaults

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

getDeletedVault

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

purgeVault

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

listKeys

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

createKey

@Named("key:create")
@POST
@Path("/keys/{keyName}/create")
Key.KeyBundle createKey(URI vaultBaseUrl,
                        @PathParam("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("key:import")
@PUT
@Path("/keys/{keyName}")
Key.KeyBundle importKey(URI vaultBaseUrl,
                        @PathParam("keyName")
                        String keyName,
                        boolean hsm,
                        @Nullable
                        Key.KeyAttributes attributes,
                        @Nullable
                        Key.JsonWebKey key,
                        @Nullable
                        Map<String,String> tags)

getKey

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

deleteKey

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

getKeyVersions

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

updateKey

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

backupKey

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

restoreKey

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

listDeletedKeys

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

getDeletedKey

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

recoverDeletedKey

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

purgeDeletedKey

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

encrypt

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

decrypt

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

sign

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

verify

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

wrap

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

unwrap

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

listSecrets

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

setSecret

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

getSecret

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

deleteSecret

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

getSecretVersions

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

updateSecret

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

backupSecret

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

restoreSecret

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

listDeletedSecrets

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

getDeletedSecret

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

recoverDeletedSecret

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

purgeDeletedSecret

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

createCertificate

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

getCertificate

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

deleteCertificate

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

getCertificates

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

getDeletedCertificates

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

getDeletedCertificate

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

recoverDeletedCertificate

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

purgeDeletedCertificate

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

getCertificateVersions

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

updateCertificate

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

importCertificate

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

mergeCertificate

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

getCertificateOperation

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

updateCertificateOperation

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

deleteCertificateOperation

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

setCertificateIssuer

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

getCertificateIssuers

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

getCertificateIssuer

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

updateCertificateIssuer

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

deleteCertificateIssuer

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

getCertificateContacts

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

setCertificateContacts

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

deleteCertificateContacts

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

getCertificatePolicy

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

updateCertificatePolicy

@Named("certificate:update_policy")
@Path("/certificates/{certificateName}/policy")
Certificate.CertificatePolicy updateCertificatePolicy(URI vaultBaseUrl,
                                                      @PathParam("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)