certificate_client_models.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/keyvault/certificates/dll_import_export.hpp"
 
#include <azure/core/context.hpp>
#include <azure/core/http/http.hpp>
#include <azure/core/nullable.hpp>
#include <azure/core/paged_response.hpp>
#include <azure/core/response.hpp>
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Azure { namespace Security { namespace KeyVault { namespace Certificates {
  namespace _detail {
    namespace Models {
      struct CertificateBundle;
      struct CertificateIssuerSetParameters;
      struct CertificateIssuerUpdateParameters;
      struct DeletedCertificateBundle;
      struct IssuerBundle;
      struct Contacts;
      struct CertificatePolicy;
      struct CertificateUpdateParameters;
      struct CertificateMergeParameters;
      struct CertificateImportParameters;
      struct CertificateCreateParameters;
      struct CertificateOperation;
      struct CertificateItem;
      struct DeletedCertificateItem;
      struct CertificateIssuerItem;
    } // namespace Models
    class GetCertificatesPagedResponse;
    class GetCertificateVersionsPagedResponse;
    class GetDeletedCertificatesPagedResponse;
    class GetCertificateIssuersPagedResponse;
  } // namespace _detail
  class CertificateClient;
  class KeyVaultCertificateWithPolicy;
  struct ImportCertificateOptions;
  struct CertificateProperties final
  {
    // Attributes
 
    Azure::Nullable<Azure::DateTime> NotBefore;
 
    Azure::Nullable<Azure::DateTime> ExpiresOn;
 
    Azure::Nullable<Azure::DateTime> CreatedOn;
 
    Azure::Nullable<Azure::DateTime> UpdatedOn;
 
    Azure::Nullable<int32_t> RecoverableDays;
 
    Azure::Nullable<std::string> RecoveryLevel;
 
    // Properties
 
    std::unordered_map<std::string, std::string> Tags;
 
    std::string Name;
 
    std::string IdUrl;
 
    std::string VaultUrl;
 
    std::string Version;
 
    std::vector<uint8_t> X509Thumbprint;
 
    Azure::Nullable<bool> Enabled;
 
    Azure::Nullable<bool> PreserveCertificateOrder;
 
    CertificateProperties() = default;
 
    CertificateProperties(std::string const& name) : Name(name) {}
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class KeyVaultCertificate;
    friend class CertificatePropertiesPagedResponse;
    CertificateProperties(_detail::Models::CertificateBundle const& bundle);
    CertificateProperties(_detail::Models::DeletedCertificateBundle const& bundle);
    _detail::Models::CertificateUpdateParameters ToCertificateUpdateParameters();
    CertificateProperties(_detail::Models::CertificateItem const& item);
  };
 
  class KeyVaultCertificate {
  public:
    std::string KeyIdUrl;
 
    std::string SecretIdUrl;
 
    CertificateProperties Properties;
 
    std::vector<uint8_t> Cer;
 
    std::string const& Name() const { return Properties.Name; }
 
    std::string const& IdUrl() const { return Properties.IdUrl; }
 
    KeyVaultCertificate(CertificateProperties const& properties) : Properties(properties) {}
 
    KeyVaultCertificate() = default;
 
    virtual ~KeyVaultCertificate() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class KeyVaultCertificateWithPolicy;
    KeyVaultCertificate(_detail::Models::CertificateBundle const& bundle);
    KeyVaultCertificate(_detail::Models::DeletedCertificateBundle const& bundle);
  };
 
  class CertificateKeyType final {
  private:
    std::string m_value;
 
  public:
    explicit CertificateKeyType(std::string keyType) : m_value(std::move(keyType)) {}
 
    CertificateKeyType() = default;
 
    bool operator==(const CertificateKeyType& other) const noexcept
    {
      return m_value == other.m_value;
    }
 
    bool operator!=(const CertificateKeyType& other) const noexcept { return !operator==(other); }
 
    std::string const& ToString() const { return m_value; }
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyType Ec;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyType EcHsm;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyType Rsa;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyType RsaHsm;
  };
 
  class CertificateKeyCurveName final {
  private:
    std::string m_value;
 
  public:
    explicit CertificateKeyCurveName(std::string value)
    {
      if (value.empty())
      {
        throw std::invalid_argument("The value for the curve name can not be empty");
      }
      m_value = std::move(value);
    }
 
    CertificateKeyCurveName() = default;
 
    bool operator==(const CertificateKeyCurveName& other) const noexcept
    {
      return m_value == other.m_value;
    }
 
    bool operator!=(const CertificateKeyCurveName& other) const noexcept
    {
      return !operator==(other);
    }
 
    std::string const& ToString() const { return m_value; }
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyCurveName P256;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyCurveName P256K;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyCurveName P384;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyCurveName P521;
  };
 
  struct SubjectAlternativeNames final
  {
    std::vector<std::string> DnsNames;
 
    std::vector<std::string> Emails;
 
    std::vector<std::string> UserPrincipalNames;
  };
 
  class CertificateContentType final {
  private:
    std::string m_value;
 
  public:
    explicit CertificateContentType(std::string value)
    {
      if (value.empty())
      {
        throw std::invalid_argument("The value for the curve name can not be empty");
      }
      m_value = std::move(value);
    }
 
    CertificateContentType() = default;
 
    bool operator==(const CertificateContentType& other) const noexcept
    {
      return m_value == other.m_value;
    }
 
    bool operator!=(const CertificateContentType& other) const noexcept
    {
      return !operator==(other);
    }
 
    std::string const& ToString() const { return m_value; }
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateContentType Pkcs12;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateContentType Pem;
  };
 
  class CertificateKeyUsage final {
  private:
    std::string m_value;
 
  public:
    explicit CertificateKeyUsage(std::string value)
    {
      if (value.empty())
      {
        throw std::invalid_argument("The value for the curve name can not be empty");
      }
      m_value = std::move(value);
    }
 
    CertificateKeyUsage() = default;
 
    bool operator==(const CertificateKeyUsage& other) const noexcept
    {
      return m_value == other.m_value;
    }
 
    bool operator!=(const CertificateKeyUsage& other) const noexcept { return !operator==(other); }
 
    std::string const& ToString() const { return m_value; }
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage DigitalSignature;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage NonRepudiation;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage KeyEncipherment;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage DataEncipherment;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage KeyAgreement;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage KeyCertSign;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage CrlSign;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage EncipherOnly;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificateKeyUsage DecipherOnly;
  };
 
  class CertificatePolicyAction final {
  private:
    std::string m_value;
 
  public:
    explicit CertificatePolicyAction(std::string value)
    {
      if (value.empty())
      {
        throw std::invalid_argument("The value for the curve name can not be empty");
      }
      m_value = std::move(value);
    }
 
    CertificatePolicyAction() = default;
 
    bool operator==(const CertificatePolicyAction& other) const noexcept
    {
      return m_value == other.m_value;
    }
 
    bool operator!=(const CertificatePolicyAction& other) const noexcept
    {
      return !operator==(other);
    }
 
    std::string const& ToString() const { return m_value; }
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificatePolicyAction
        DigitalSignature;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificatePolicyAction AutoRenew;
 
    AZ_SECURITY_KEYVAULT_CERTIFICATES_DLLEXPORT static const CertificatePolicyAction EmailContacts;
  };
 
  struct LifetimeAction final
  {
    CertificatePolicyAction Action;
 
    Azure::Nullable<int32_t> DaysBeforeExpiry;
 
    Azure::Nullable<int32_t> LifetimePercentage;
  };
 
  struct CertificatePolicy final
  {
    Azure::Nullable<CertificateKeyType> KeyType;
 
    Azure::Nullable<bool> ReuseKey;
 
    Azure::Nullable<bool> Exportable;
 
    Azure::Nullable<CertificateKeyCurveName> KeyCurveName;
 
    Azure::Nullable<int32_t> KeySize;
 
    std::string Subject;
 
    struct SubjectAlternativeNames SubjectAlternativeNames;
 
    Azure::Nullable<bool> CertificateTransparency;
 
    Azure::Nullable<std::string> CertificateType;
 
    Azure::Nullable<std::string> IssuerName;
 
    Azure::Nullable<CertificateContentType> ContentType;
 
    Azure::Nullable<int32_t> ValidityInMonths;
 
    Azure::Nullable<bool> Enabled;
 
    Azure::Nullable<Azure::DateTime> UpdatedOn;
 
    Azure::Nullable<Azure::DateTime> CreatedOn;
 
    std::vector<CertificateKeyUsage> KeyUsage;
 
    std::vector<std::string> EnhancedKeyUsage;
 
    std::vector<LifetimeAction> LifetimeActions;
 
    CertificatePolicy() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend struct _detail::Models::CertificatePolicy;
    friend class KeyVaultCertificateWithPolicy;
    friend struct ImportCertificateOptions;
    friend class CertificateCreateOptions;
    CertificatePolicy(_detail::Models::CertificatePolicy const& policy);
    _detail::Models::CertificatePolicy ToCertificatePolicy() const;
  };
 
  class KeyVaultCertificateWithPolicy : public KeyVaultCertificate {
  public:
    CertificatePolicy Policy;
 
    KeyVaultCertificateWithPolicy(CertificateProperties const& properties)
        : KeyVaultCertificate(properties)
    {
    }
 
    KeyVaultCertificateWithPolicy() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class DeletedCertificate;
    KeyVaultCertificateWithPolicy(_detail::Models::CertificateBundle const& bundle);
    KeyVaultCertificateWithPolicy(_detail::Models::DeletedCertificateBundle const& bundle);
  };
 
  class CertificateCreateOptions final {
  public:
    CertificatePolicy Policy;
 
    CertificateProperties Properties;
 
    Azure::Nullable<bool> Enabled() { return Properties.Enabled; }
 
    std::unordered_map<std::string, std::string> Tags;
 
    CertificateCreateOptions() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    _detail::Models::CertificateCreateParameters ToCertificateCreateParameters();
  };
 
  struct CertificateOperationUpdateOptions final
  {
 
    bool CancelationRequested;
  };
 
  struct IssuerCredentials final
  {
    Azure::Nullable<std::string> AccountId;
 
    Azure::Nullable<std::string> Password;
  };
 
  struct AdministratorDetails final
  {
    Azure::Nullable<std::string> FirstName;
 
    Azure::Nullable<std::string> LastName;
 
    Azure::Nullable<std::string> EmailAddress;
 
    Azure::Nullable<std::string> PhoneNumber;
  };
 
  struct IssuerProperties final
  {
    Azure::Nullable<bool> Enabled;
 
    Azure::Nullable<DateTime> Created;
 
    Azure::Nullable<DateTime> Updated;
  };
 
  struct OrganizationDetails final
  {
    Azure::Nullable<std::string> Id;
 
    std::vector<AdministratorDetails> AdminDetails;
  };
 
  struct CertificateIssuer final
  {
    std::string Name;
 
    Azure::Nullable<std::string> IdUrl;
 
    Azure::Nullable<std::string> Provider;
 
    IssuerCredentials Credentials;
 
    OrganizationDetails Organization;
 
    IssuerProperties Properties;
 
    CertificateIssuer() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    CertificateIssuer(std::string const& name, _detail::Models::IssuerBundle const& issuer);
    _detail::Models::CertificateIssuerSetParameters ToCertificateIssuerSetParameters();
    _detail::Models::CertificateIssuerUpdateParameters ToCertificateIssuerUpdateParameters();
  };
 
  struct CertificateContact final
  {
    std::string EmailAddress;
 
    Azure::Nullable<std::string> Name;
 
    Azure::Nullable<std::string> Phone;
  };
 
  class ServerError final {
  public:
    ~ServerError() = default;
    std::string Code;
 
    std::string Message;
 
    std::shared_ptr<ServerError> InnerError;
  };
 
  class CertificateOperationProperties final {
  public:
    std::string IdUrl;
 
    std::string Name;
 
    std::string VaultUrl;
 
    std::vector<uint8_t> Csr;
 
    Azure::Nullable<bool> CancellationRequested;
 
    Azure::Nullable<std::string> Status;
 
    Azure::Nullable<std::string> StatusDetails;
 
    Azure::Nullable<std::string> Target;
 
    Azure::Nullable<std::string> RequestIdUrl;
 
    Azure::Nullable<std::string> IssuerName;
 
    Azure::Nullable<std::string> CertificateType;
 
    Azure::Nullable<bool> CertificateTransparency;
 
    Azure::Nullable<ServerError> Error;
 
    Azure::Nullable<bool> PreserveCertificateOrder;
 
    ~CertificateOperationProperties() = default;
    CertificateOperationProperties() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    CertificateOperationProperties(_detail::Models::CertificateOperation const& operation);
  };
 
  class DeletedCertificate final : public KeyVaultCertificateWithPolicy {
  public:
    std::string RecoveryIdUrl;
 
    Azure::Nullable<DateTime> DeletedOn;
 
    Azure::Nullable<DateTime> ScheduledPurgeDate;
 
    DeletedCertificate() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class DeletedCertificatesPagedResponse;
    DeletedCertificate(_detail::Models::DeletedCertificateBundle const& bundle);
    DeletedCertificate(_detail::Models::DeletedCertificateItem const& item);
  };
 
  struct PurgedCertificate final
  {
  };
  struct GetPropertiesOfCertificatesOptions final
  {
    Azure::Nullable<std::string> NextPageToken;
    Azure::Nullable<bool> IncludePending;
  };
 
  struct GetPropertiesOfCertificateVersionsOptions final
  {
    Azure::Nullable<std::string> NextPageToken;
  };
 
  struct GetPropertiesOfIssuersOptions final
  {
    Azure::Nullable<std::string> NextPageToken;
  };
 
  struct GetDeletedCertificatesOptions final
  {
    Azure::Nullable<std::string> NextPageToken;
  };
  struct BackupCertificateResult final
  {
    std::vector<uint8_t> Certificate;
  };
 
  struct CertificateIssuerItem final
  {
    std::string Name;
    std::string IdUrl;
    std::string Provider;
 
    CertificateIssuerItem() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class IssuerPropertiesPagedResponse;
    CertificateIssuerItem(_detail::Models::CertificateIssuerItem const& item);
  };
 
  class CertificatePropertiesPagedResponse final
      : public Azure::Core::PagedResponse<CertificatePropertiesPagedResponse> {
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class Azure::Core::PagedResponse<CertificatePropertiesPagedResponse>;
 
    std::string m_certificateName;
    std::shared_ptr<CertificateClient> m_certificateClient;
    void OnNextPage(const Azure::Core::Context&);
 
    CertificatePropertiesPagedResponse(
        CertificatePropertiesPagedResponse&& certificateProperties,
        std::unique_ptr<Azure::Core::Http::RawResponse> rawResponse,
        std::shared_ptr<CertificateClient> certificateClient,
        std::string const& certificateName = std::string())
        : PagedResponse(std::move(certificateProperties)), m_certificateName(certificateName),
          m_certificateClient(certificateClient), Items(std::move(certificateProperties.Items))
    {
      RawResponse = std::move(rawResponse);
    }
    CertificatePropertiesPagedResponse(_detail::GetCertificatesPagedResponse& pagedResponse);
    CertificatePropertiesPagedResponse(_detail::GetCertificateVersionsPagedResponse& pagedResponse);
 
  public:
    CertificatePropertiesPagedResponse() = default;
 
    std::vector<CertificateProperties> Items;
  };
 
  class IssuerPropertiesPagedResponse final
      : public Azure::Core::PagedResponse<IssuerPropertiesPagedResponse> {
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    friend class Azure::Core::PagedResponse<IssuerPropertiesPagedResponse>;
 
    std::shared_ptr<CertificateClient> m_certificateClient;
    void OnNextPage(const Azure::Core::Context&);
 
    IssuerPropertiesPagedResponse(
        IssuerPropertiesPagedResponse&& issuerProperties,
        std::unique_ptr<Azure::Core::Http::RawResponse> rawResponse,
        std::shared_ptr<CertificateClient> certificateClient)
        : PagedResponse(std::move(issuerProperties)), m_certificateClient(certificateClient),
          Items(std::move(issuerProperties.Items))
    {
      RawResponse = std::move(rawResponse);
    }
    IssuerPropertiesPagedResponse(_detail::GetCertificateIssuersPagedResponse& pagedResponse);
 
  public:
    IssuerPropertiesPagedResponse() = default;
 
    std::vector<CertificateIssuerItem> Items;
  };
 
  class DeletedCertificatesPagedResponse final
      : public Azure::Core::PagedResponse<DeletedCertificatesPagedResponse> {
  private:
    friend class CertificateClient;
    friend class Azure::Core::PagedResponse<DeletedCertificatesPagedResponse>;
 
    std::shared_ptr<CertificateClient> m_certificateClient;
    void OnNextPage(const Azure::Core::Context&);
 
    DeletedCertificatesPagedResponse(
        DeletedCertificatesPagedResponse&& deletedProperties,
        std::unique_ptr<Azure::Core::Http::RawResponse> rawResponse,
        std::shared_ptr<CertificateClient> certificateClient)
        : PagedResponse(std::move(deletedProperties)), m_certificateClient(certificateClient),
          Items(std::move(deletedProperties.Items))
    {
      RawResponse = std::move(rawResponse);
    }
    DeletedCertificatesPagedResponse(_detail::GetDeletedCertificatesPagedResponse& pagedResponse);
 
  public:
    DeletedCertificatesPagedResponse() = default;
 
    std::vector<DeletedCertificate> Items;
  };
 
  struct KeyVaultSecret final
  {
    Azure::Nullable<CertificateContentType> ContentType;
    std::string Value;
  };
 
  struct ImportCertificateOptions final
  {
    std::string Certificate;
 
    Azure::Nullable<std::string> Password;
 
    CertificatePolicy Policy;
 
    CertificateProperties Properties;
 
    std::unordered_map<std::string, std::string> Tags;
 
    ImportCertificateOptions() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    _detail::Models::CertificateImportParameters ToCertificateImportParameters();
  };
 
  struct MergeCertificateOptions final
  { 
    std::vector<std::string> Certificates;
    CertificateProperties Properties;
    std::unordered_map<std::string, std::string> Tags;
 
    MergeCertificateOptions() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    _detail::Models::CertificateMergeParameters ToCertificateMergeParameters();
  };
 
  struct CertificateUpdateOptions final
  {
    CertificateProperties Properties;
    std::unordered_map<std::string, std::string> Tags;
  };
 
  struct CertificateContactsResult
  {
    std::vector<CertificateContact> Contacts;
 
    CertificateContactsResult() = default;
 
  private:
    // added friend classes to access private members
    // for mapping from the old model to the new one
    friend class CertificateClient;
    CertificateContactsResult(_detail::Models::Contacts contacts);
  };
 
}}}} // namespace Azure::Security::KeyVault::Certificates