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)