rest_client.hpp

 
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
//
// Code generated by Microsoft (R) AutoRest C++ Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
#pragma once
 
#include <azure/core/case_insensitive_containers.hpp>
#include <azure/core/context.hpp>
#include <azure/core/datetime.hpp>
#include <azure/core/etag.hpp>
#include <azure/core/http/http.hpp>
#include <azure/core/internal/extendable_enumeration.hpp>
#include <azure/core/internal/http/pipeline.hpp>
#include <azure/core/io/body_stream.hpp>
#include <azure/core/nullable.hpp>
#include <azure/core/response.hpp>
#include <azure/core/url.hpp>
#include <azure/storage/blobs/dll_import_export.hpp>
#include <azure/storage/common/storage_common.hpp>
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
namespace Azure { namespace Storage { namespace Blobs {
  namespace _detail {
    constexpr static const char* ApiVersion = "2026-02-06";
  } // namespace _detail
  namespace Models {
    class EncryptionAlgorithmType final
        : public Core::_internal::ExtendableEnumeration<EncryptionAlgorithmType> {
    public:
      EncryptionAlgorithmType() = default;
      explicit EncryptionAlgorithmType(std::string value) : ExtendableEnumeration(std::move(value))
      {
      }
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static EncryptionAlgorithmType Aes256;
    };
    class BlockType final : public Core::_internal::ExtendableEnumeration<BlockType> {
    public:
      BlockType() = default;
      explicit BlockType(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlockType Committed;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlockType Uncommitted;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlockType Latest;
    };
    struct RetentionPolicy final
    {
      bool IsEnabled = bool();
      Nullable<std::int32_t> Days;
    };
    struct AnalyticsLogging final
    {
      std::string Version;
      bool Delete = bool();
      bool Read = bool();
      bool Write = bool();
      Models::RetentionPolicy RetentionPolicy;
    };
    struct Metrics final
    {
      std::string Version;
      bool IsEnabled = bool();
      Nullable<bool> IncludeApis;
      Models::RetentionPolicy RetentionPolicy;
    };
    struct CorsRule final
    {
      std::string AllowedOrigins;
      std::string AllowedMethods;
      std::string AllowedHeaders;
      std::string ExposedHeaders;
      std::int32_t MaxAgeInSeconds = std::int32_t();
    };
    struct StaticWebsite final
    {
      bool IsEnabled = bool();
      Nullable<std::string> IndexDocument;
      Nullable<std::string> ErrorDocument404Path;
      Nullable<std::string> DefaultIndexDocumentPath;
    };
    struct SetServicePropertiesResult final
    {
    };
    struct BlobServiceProperties final
    {
      AnalyticsLogging Logging;
      Metrics HourMetrics;
      Metrics MinuteMetrics;
      std::vector<CorsRule> Cors;
      Nullable<std::string> DefaultServiceVersion;
      RetentionPolicy DeleteRetentionPolicy;
      Models::StaticWebsite StaticWebsite;
    };
    class GeoReplicationStatus final
        : public Core::_internal::ExtendableEnumeration<GeoReplicationStatus> {
    public:
      GeoReplicationStatus() = default;
      explicit GeoReplicationStatus(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static GeoReplicationStatus Live;
      AZ_STORAGE_BLOBS_DLLEXPORT const static GeoReplicationStatus Bootstrap;
      AZ_STORAGE_BLOBS_DLLEXPORT const static GeoReplicationStatus Unavailable;
    };
    struct GeoReplication final
    {
      GeoReplicationStatus Status;
      Nullable<DateTime> LastSyncedOn;
    };
    struct ServiceStatistics final
    {
      Models::GeoReplication GeoReplication;
    };
    class LeaseStatus final : public Core::_internal::ExtendableEnumeration<LeaseStatus> {
    public:
      LeaseStatus() = default;
      explicit LeaseStatus(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseStatus Locked;
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseStatus Unlocked;
    };
    class LeaseState final : public Core::_internal::ExtendableEnumeration<LeaseState> {
    public:
      LeaseState() = default;
      explicit LeaseState(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseState Available;
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseState Leased;
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseState Expired;
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseState Breaking;
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseState Broken;
    };
    class LeaseDurationType final
        : public Core::_internal::ExtendableEnumeration<LeaseDurationType> {
    public:
      LeaseDurationType() = default;
      explicit LeaseDurationType(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseDurationType Infinite;
      AZ_STORAGE_BLOBS_DLLEXPORT const static LeaseDurationType Fixed;
    };
    class PublicAccessType final : public Core::_internal::ExtendableEnumeration<PublicAccessType> {
    public:
      PublicAccessType() = default;
      explicit PublicAccessType(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static PublicAccessType BlobContainer;
      AZ_STORAGE_BLOBS_DLLEXPORT const static PublicAccessType Blob;
      AZ_STORAGE_BLOBS_DLLEXPORT const static PublicAccessType None;
    };
    struct BlobContainerItemDetails final
    {
      DateTime LastModified;
      Azure::ETag ETag;
      Models::LeaseStatus LeaseStatus;
      Models::LeaseState LeaseState;
      Nullable<LeaseDurationType> LeaseDuration;
      PublicAccessType AccessType;
      bool HasImmutabilityPolicy = bool();
      bool HasLegalHold = bool();
      std::string DefaultEncryptionScope = "$account-encryption-key";
      bool PreventEncryptionScopeOverride = false;
      Nullable<DateTime> DeletedOn;
      Nullable<std::int32_t> RemainingRetentionDays;
      bool HasImmutableStorageWithVersioning = false;
      Core::CaseInsensitiveMap Metadata;
    };
    struct BlobContainerItem final
    {
      std::string Name;
      bool IsDeleted = bool();
      Nullable<std::string> VersionId;
      BlobContainerItemDetails Details;
    };
    enum class ListBlobContainersIncludeFlags
    {
      None = 0,
      Metadata = 1,
      Deleted = 2,
      System = 4,
    };
    inline ListBlobContainersIncludeFlags operator|(
        ListBlobContainersIncludeFlags lhs,
        ListBlobContainersIncludeFlags rhs)
    {
      using type = std::underlying_type_t<ListBlobContainersIncludeFlags>;
      return static_cast<ListBlobContainersIncludeFlags>(
          static_cast<type>(lhs) | static_cast<type>(rhs));
    }
    inline ListBlobContainersIncludeFlags& operator|=(
        ListBlobContainersIncludeFlags& lhs,
        ListBlobContainersIncludeFlags rhs)
    {
      lhs = lhs | rhs;
      return lhs;
    }
    inline ListBlobContainersIncludeFlags operator&(
        ListBlobContainersIncludeFlags lhs,
        ListBlobContainersIncludeFlags rhs)
    {
      using type = std::underlying_type_t<ListBlobContainersIncludeFlags>;
      return static_cast<ListBlobContainersIncludeFlags>(
          static_cast<type>(lhs) & static_cast<type>(rhs));
    }
    inline ListBlobContainersIncludeFlags& operator&=(
        ListBlobContainersIncludeFlags& lhs,
        ListBlobContainersIncludeFlags rhs)
    {
      lhs = lhs & rhs;
      return lhs;
    }
    namespace _detail {
      struct ListBlobContainersResult final
      {
        std::string ServiceEndpoint;
        std::string Prefix;
        Nullable<std::string> ContinuationToken;
        std::vector<BlobContainerItem> Items;
      };
      struct KeyInfo final
      {
        std::string Start;
        std::string Expiry;
      };
    } // namespace _detail
    struct UserDelegationKey final
    {
      std::string SignedObjectId;
      std::string SignedTenantId;
      DateTime SignedStartsOn;
      DateTime SignedExpiresOn;
      std::string SignedService;
      std::string SignedVersion;
      std::string Value;
    };
    class SkuName final : public Core::_internal::ExtendableEnumeration<SkuName> {
    public:
      SkuName() = default;
      explicit SkuName(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName StandardLrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName StandardGrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName StandardRagrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName StandardZrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName PremiumLrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName PremiumZrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName StandardGzrs;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SkuName StandardRagzrs;
    };
    class AccountKind final : public Core::_internal::ExtendableEnumeration<AccountKind> {
    public:
      AccountKind() = default;
      explicit AccountKind(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccountKind Storage;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccountKind BlobStorage;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccountKind StorageV2;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccountKind FileStorage;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccountKind BlockBlobStorage;
    };
    struct TaggedBlobItem final
    {
      std::string BlobName;
      std::string BlobContainerName;
      std::map<std::string, std::string> Tags;
    };
    struct CreateBlobContainerResult final
    {
      bool Created = true;
      Azure::ETag ETag;
      DateTime LastModified;
    };
    struct BlobContainerProperties final
    {
      Core::CaseInsensitiveMap Metadata;
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<LeaseDurationType> LeaseDuration;
      Models::LeaseState LeaseState;
      Models::LeaseStatus LeaseStatus;
      PublicAccessType AccessType = PublicAccessType::None;
      bool HasImmutabilityPolicy = bool();
      bool HasLegalHold = bool();
      std::string DefaultEncryptionScope = "$account-encryption-key";
      bool PreventEncryptionScopeOverride = false;
      bool HasImmutableStorageWithVersioning = false;
    };
    struct DeleteBlobContainerResult final
    {
      bool Deleted = true;
    };
    struct SetBlobContainerMetadataResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
    };
    struct SignedIdentifier final
    {
      std::string Id;
      Nullable<DateTime> StartsOn;
      Nullable<DateTime> ExpiresOn;
      std::string Permissions;
    };
    struct BlobContainerAccessPolicy final
    {
      std::vector<SignedIdentifier> SignedIdentifiers;
      PublicAccessType AccessType = PublicAccessType::None;
    };
    struct SetBlobContainerAccessPolicyResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
    };
    namespace _detail {
      struct UndeleteBlobContainerResult final
      {
      };
      struct RenameBlobContainerResult final
      {
      };
      struct SubmitBatchResult final
      {
        std::unique_ptr<Core::IO::BodyStream> BodyStream;
        std::string ContentType;
      };
      struct FindBlobsByTagsResult final
      {
        std::string ServiceEndpoint;
        std::vector<TaggedBlobItem> Items;
        Nullable<std::string> ContinuationToken;
      };
      struct AcquireBlobContainerLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string LeaseId;
      };
      struct ReleaseBlobContainerLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
      };
      struct RenewBlobContainerLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string LeaseId;
      };
      struct BreakBlobContainerLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::int32_t LeaseTime = std::int32_t();
      };
      struct ChangeBlobContainerLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string LeaseId;
      };
      struct BlobName final
      {
        bool Encoded = bool();
        std::string Content;
      };
    } // namespace _detail
    class CopyStatus final : public Core::_internal::ExtendableEnumeration<CopyStatus> {
    public:
      CopyStatus() = default;
      explicit CopyStatus(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static CopyStatus Pending;
      AZ_STORAGE_BLOBS_DLLEXPORT const static CopyStatus Success;
      AZ_STORAGE_BLOBS_DLLEXPORT const static CopyStatus Aborted;
      AZ_STORAGE_BLOBS_DLLEXPORT const static CopyStatus Failed;
    };
    class AccessTier final : public Core::_internal::ExtendableEnumeration<AccessTier> {
    public:
      AccessTier() = default;
      explicit AccessTier(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P1;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P2;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P3;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P4;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P6;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P10;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P15;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P20;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P30;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P40;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P50;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P60;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P70;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier P80;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier Hot;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier Cool;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier Archive;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier Premium;
      AZ_STORAGE_BLOBS_DLLEXPORT const static AccessTier Cold;
    };
    class ArchiveStatus final : public Core::_internal::ExtendableEnumeration<ArchiveStatus> {
    public:
      ArchiveStatus() = default;
      explicit ArchiveStatus(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static ArchiveStatus RehydratePendingToHot;
      AZ_STORAGE_BLOBS_DLLEXPORT const static ArchiveStatus RehydratePendingToCool;
      AZ_STORAGE_BLOBS_DLLEXPORT const static ArchiveStatus RehydratePendingToCold;
    };
    class RehydratePriority final
        : public Core::_internal::ExtendableEnumeration<RehydratePriority> {
    public:
      RehydratePriority() = default;
      explicit RehydratePriority(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static RehydratePriority High;
      AZ_STORAGE_BLOBS_DLLEXPORT const static RehydratePriority Standard;
    };
    struct BlobHttpHeaders final
    {
      std::string ContentType;
      std::string ContentEncoding;
      std::string ContentLanguage;
      Storage::ContentHash ContentHash;
      std::string ContentDisposition;
      std::string CacheControl;
    };
    class ObjectReplicationStatus final
        : public Core::_internal::ExtendableEnumeration<ObjectReplicationStatus> {
    public:
      ObjectReplicationStatus() = default;
      explicit ObjectReplicationStatus(std::string value) : ExtendableEnumeration(std::move(value))
      {
      }
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static ObjectReplicationStatus Complete;
      AZ_STORAGE_BLOBS_DLLEXPORT const static ObjectReplicationStatus Failed;
    };
    struct ObjectReplicationRule final
    {
      std::string RuleId;
      ObjectReplicationStatus ReplicationStatus;
    };
    struct ObjectReplicationPolicy final
    {
      std::string PolicyId;
      std::vector<ObjectReplicationRule> Rules;
    };
    class BlobImmutabilityPolicyMode final
        : public Core::_internal::ExtendableEnumeration<BlobImmutabilityPolicyMode> {
    public:
      BlobImmutabilityPolicyMode() = default;
      explicit BlobImmutabilityPolicyMode(std::string value)
          : ExtendableEnumeration(std::move(value))
      {
      }
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobImmutabilityPolicyMode Unlocked;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobImmutabilityPolicyMode Locked;
    };
    struct BlobImmutabilityPolicy final
    {
      DateTime ExpiresOn;
      BlobImmutabilityPolicyMode PolicyMode;
    };
    struct BlobItemDetails final
    {
      DateTime CreatedOn;
      DateTime LastModified;
      Azure::ETag ETag;
      Nullable<std::int64_t> SequenceNumber;
      Models::LeaseStatus LeaseStatus;
      Models::LeaseState LeaseState;
      Nullable<LeaseDurationType> LeaseDuration;
      Nullable<std::string> CopyId;
      Nullable<Models::CopyStatus> CopyStatus;
      Nullable<std::string> CopySource;
      Nullable<std::string> CopyProgress;
      Nullable<DateTime> CopyCompletedOn;
      Nullable<std::string> CopyStatusDescription;
      bool IsServerEncrypted = bool();
      Nullable<bool> IsIncrementalCopy;
      Nullable<std::string> IncrementalCopyDestinationSnapshot;
      Nullable<DateTime> DeletedOn;
      Nullable<std::int32_t> RemainingRetentionDays;
      Nullable<Models::AccessTier> AccessTier;
      Nullable<bool> IsAccessTierInferred;
      Nullable<Models::ArchiveStatus> ArchiveStatus;
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
      Nullable<DateTime> AccessTierChangedOn;
      Nullable<DateTime> ExpiresOn;
      Nullable<bool> IsSealed;
      Nullable<Models::RehydratePriority> RehydratePriority;
      Nullable<DateTime> LastAccessedOn;
      bool HasLegalHold = false;
      BlobHttpHeaders HttpHeaders;
      Core::CaseInsensitiveMap Metadata;
      std::map<std::string, std::string> Tags;
      std::vector<ObjectReplicationPolicy> ObjectReplicationSourceProperties;
      Nullable<BlobImmutabilityPolicy> ImmutabilityPolicy;
    };
    class BlobType final : public Core::_internal::ExtendableEnumeration<BlobType> {
    public:
      BlobType() = default;
      explicit BlobType(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobType BlockBlob;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobType PageBlob;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobType AppendBlob;
    };
    namespace _detail {
      struct BlobItem final
      {
        BlobName Name;
        bool IsDeleted = bool();
        std::string Snapshot;
        Nullable<std::string> VersionId;
        Nullable<bool> IsCurrentVersion;
        BlobItemDetails Details;
        Nullable<bool> HasVersionsOnly;
        std::int64_t BlobSize = std::int64_t();
        Models::BlobType BlobType;
        Nullable<std::string> DeletionId;
      };
    } // namespace _detail
    enum class ListBlobsIncludeFlags
    {
      None = 0,
      Copy = 1,
      Deleted = 2,
      Metadata = 4,
      Snapshots = 8,
      UncomittedBlobs = 16,
      Versions = 32,
      Tags = 64,
      ImmutabilityPolicy = 128,
      LegalHold = 256,
      DeletedWithVersions = 512,
    };
    inline ListBlobsIncludeFlags operator|(ListBlobsIncludeFlags lhs, ListBlobsIncludeFlags rhs)
    {
      using type = std::underlying_type_t<ListBlobsIncludeFlags>;
      return static_cast<ListBlobsIncludeFlags>(static_cast<type>(lhs) | static_cast<type>(rhs));
    }
    inline ListBlobsIncludeFlags& operator|=(ListBlobsIncludeFlags& lhs, ListBlobsIncludeFlags rhs)
    {
      lhs = lhs | rhs;
      return lhs;
    }
    inline ListBlobsIncludeFlags operator&(ListBlobsIncludeFlags lhs, ListBlobsIncludeFlags rhs)
    {
      using type = std::underlying_type_t<ListBlobsIncludeFlags>;
      return static_cast<ListBlobsIncludeFlags>(static_cast<type>(lhs) & static_cast<type>(rhs));
    }
    inline ListBlobsIncludeFlags& operator&=(ListBlobsIncludeFlags& lhs, ListBlobsIncludeFlags rhs)
    {
      lhs = lhs & rhs;
      return lhs;
    }
    namespace _detail {
      struct ListBlobsResult final
      {
        std::string ServiceEndpoint;
        std::string BlobContainerName;
        std::string Prefix;
        Nullable<std::string> ContinuationToken;
        std::vector<BlobItem> Items;
      };
      struct ListBlobsByHierarchyResult final
      {
        std::string ServiceEndpoint;
        std::string BlobContainerName;
        std::string Prefix;
        std::string Delimiter;
        Nullable<std::string> ContinuationToken;
        std::vector<BlobItem> Items;
        std::vector<BlobName> BlobPrefixes;
      };
    } // namespace _detail
    struct DownloadBlobDetails final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      DateTime CreatedOn;
      Nullable<DateTime> ExpiresOn;
      Nullable<DateTime> LastAccessedOn;
      BlobHttpHeaders HttpHeaders;
      Core::CaseInsensitiveMap Metadata;
      Nullable<std::int64_t> SequenceNumber;
      Nullable<std::int32_t> CommittedBlockCount;
      Nullable<bool> IsSealed;
      Nullable<LeaseDurationType> LeaseDuration;
      Nullable<Models::LeaseState> LeaseState;
      Nullable<Models::LeaseStatus> LeaseStatus;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
      Nullable<std::string> ObjectReplicationDestinationPolicyId;
      std::vector<ObjectReplicationPolicy> ObjectReplicationSourceProperties;
      Nullable<std::int32_t> TagCount;
      Nullable<std::string> CopyId;
      Nullable<std::string> CopySource;
      Nullable<Models::CopyStatus> CopyStatus;
      Nullable<std::string> CopyStatusDescription;
      Nullable<std::string> CopyProgress;
      Nullable<DateTime> CopyCompletedOn;
      Nullable<std::string> VersionId;
      Nullable<bool> IsCurrentVersion;
      Nullable<BlobImmutabilityPolicy> ImmutabilityPolicy;
      bool HasLegalHold = false;
    };
    struct DownloadBlobResult final
    {
      DownloadBlobDetails Details;
      std::int64_t BlobSize = std::int64_t();
      Core::Http::HttpRange ContentRange;
      Nullable<ContentHash> TransactionalContentHash;
      std::unique_ptr<Core::IO::BodyStream> BodyStream;
      Models::BlobType BlobType;
    };
    struct BlobProperties final
    {
      std::vector<ObjectReplicationPolicy> ObjectReplicationSourceProperties;
      Nullable<BlobImmutabilityPolicy> ImmutabilityPolicy;
      BlobHttpHeaders HttpHeaders;
      DateTime LastModified;
      DateTime CreatedOn;
      Core::CaseInsensitiveMap Metadata;
      Nullable<std::string> ObjectReplicationDestinationPolicyId;
      Models::BlobType BlobType;
      Nullable<DateTime> CopyCompletedOn;
      Nullable<std::string> CopyStatusDescription;
      Nullable<std::string> CopyId;
      Nullable<std::string> CopyProgress;
      Nullable<std::string> CopySource;
      Nullable<Models::CopyStatus> CopyStatus;
      Nullable<bool> IsIncrementalCopy;
      Nullable<std::string> IncrementalCopyDestinationSnapshot;
      Nullable<LeaseDurationType> LeaseDuration;
      Nullable<Models::LeaseState> LeaseState;
      Nullable<Models::LeaseStatus> LeaseStatus;
      std::int64_t BlobSize = std::int64_t();
      Azure::ETag ETag;
      Nullable<std::int64_t> SequenceNumber;
      Nullable<std::int32_t> CommittedBlockCount;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
      Nullable<Models::AccessTier> AccessTier;
      Nullable<bool> IsAccessTierInferred;
      Nullable<Models::ArchiveStatus> ArchiveStatus;
      Nullable<DateTime> AccessTierChangedOn;
      Nullable<std::string> VersionId;
      Nullable<bool> IsCurrentVersion;
      Nullable<std::int32_t> TagCount;
      Nullable<DateTime> ExpiresOn;
      Nullable<bool> IsSealed;
      Nullable<Models::RehydratePriority> RehydratePriority;
      Nullable<DateTime> LastAccessedOn;
      bool HasLegalHold = false;
    };
    class DeleteSnapshotsOption final
        : public Core::_internal::ExtendableEnumeration<DeleteSnapshotsOption> {
    public:
      DeleteSnapshotsOption() = default;
      explicit DeleteSnapshotsOption(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static DeleteSnapshotsOption IncludeSnapshots;
      AZ_STORAGE_BLOBS_DLLEXPORT const static DeleteSnapshotsOption OnlySnapshots;
    };
    struct DeleteBlobResult final
    {
      bool Deleted = true;
    };
    struct UndeleteBlobResult final
    {
    };
    class ScheduleBlobExpiryOriginType final
        : public Core::_internal::ExtendableEnumeration<ScheduleBlobExpiryOriginType> {
    public:
      ScheduleBlobExpiryOriginType() = default;
      explicit ScheduleBlobExpiryOriginType(std::string value)
          : ExtendableEnumeration(std::move(value))
      {
      }
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static ScheduleBlobExpiryOriginType NeverExpire;
      AZ_STORAGE_BLOBS_DLLEXPORT const static ScheduleBlobExpiryOriginType RelativeToCreation;
      AZ_STORAGE_BLOBS_DLLEXPORT const static ScheduleBlobExpiryOriginType RelativeToNow;
      AZ_STORAGE_BLOBS_DLLEXPORT const static ScheduleBlobExpiryOriginType Absolute;
    };
    struct SetBlobExpiryResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
    };
    struct SetBlobHttpHeadersResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<std::int64_t> SequenceNumber;
    };
    struct SetBlobImmutabilityPolicyResult final
    {
      BlobImmutabilityPolicy ImmutabilityPolicy;
    };
    struct DeleteBlobImmutabilityPolicyResult final
    {
    };
    struct SetBlobLegalHoldResult final
    {
      bool HasLegalHold = bool();
    };
    struct SetBlobMetadataResult final
    {
      Nullable<std::int64_t> SequenceNumber;
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    namespace _detail {
      struct AcquireBlobLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string LeaseId;
      };
      struct ReleaseBlobLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
      };
      struct RenewBlobLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string LeaseId;
      };
      struct ChangeBlobLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string LeaseId;
      };
      struct BreakBlobLeaseResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::int32_t LeaseTime = std::int32_t();
      };
    } // namespace _detail
    struct CreateBlobSnapshotResult final
    {
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
      std::string Snapshot;
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
    };
    namespace _detail {
      struct StartBlobCopyFromUriResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        Nullable<std::string> VersionId;
        std::string CopyId;
        Models::CopyStatus CopyStatus;
      };
    } // namespace _detail
    class BlobCopySourceTagsMode final
        : public Core::_internal::ExtendableEnumeration<BlobCopySourceTagsMode> {
    public:
      BlobCopySourceTagsMode() = default;
      explicit BlobCopySourceTagsMode(std::string value) : ExtendableEnumeration(std::move(value))
      {
      }
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobCopySourceTagsMode Replace;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobCopySourceTagsMode Copy;
    };
    class FileShareTokenIntent final
        : public Core::_internal::ExtendableEnumeration<FileShareTokenIntent> {
    public:
      FileShareTokenIntent() = default;
      explicit FileShareTokenIntent(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static FileShareTokenIntent Backup;
    };
    struct CopyBlobFromUriResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<std::string> VersionId;
      std::string CopyId;
      Models::CopyStatus CopyStatus;
      Nullable<ContentHash> TransactionalContentHash;
      Nullable<std::string> EncryptionScope;
    };
    struct AbortBlobCopyFromUriResult final
    {
    };
    struct SetBlobAccessTierResult final
    {
    };
    struct AccountInfo final
    {
      Models::SkuName SkuName;
      Models::AccountKind AccountKind;
      bool IsHierarchicalNamespaceEnabled = bool();
    };
    namespace _detail {
      class QueryRequestQueryType final
          : public Core::_internal::ExtendableEnumeration<QueryRequestQueryType> {
      public:
        QueryRequestQueryType() = default;
        explicit QueryRequestQueryType(std::string value) : ExtendableEnumeration(std::move(value))
        {
        }
 
        AZ_STORAGE_BLOBS_DLLEXPORT const static QueryRequestQueryType SQL;
      };
      class QueryFormatType final : public Core::_internal::ExtendableEnumeration<QueryFormatType> {
      public:
        QueryFormatType() = default;
        explicit QueryFormatType(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
        AZ_STORAGE_BLOBS_DLLEXPORT const static QueryFormatType Delimited;
        AZ_STORAGE_BLOBS_DLLEXPORT const static QueryFormatType Json;
        AZ_STORAGE_BLOBS_DLLEXPORT const static QueryFormatType Arrow;
        AZ_STORAGE_BLOBS_DLLEXPORT const static QueryFormatType Parquet;
      };
      struct DelimitedTextConfiguration final
      {
        std::string ColumnSeparator;
        std::string FieldQuote;
        std::string RecordSeparator;
        std::string EscapeChar;
        bool HeadersPresent = bool();
      };
      struct JsonTextConfiguration final
      {
        std::string RecordSeparator;
      };
    } // namespace _detail
    class BlobQueryArrowFieldType final
        : public Core::_internal::ExtendableEnumeration<BlobQueryArrowFieldType> {
    public:
      BlobQueryArrowFieldType() = default;
      explicit BlobQueryArrowFieldType(std::string value) : ExtendableEnumeration(std::move(value))
      {
      }
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobQueryArrowFieldType Int64;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobQueryArrowFieldType Bool;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobQueryArrowFieldType Timestamp;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobQueryArrowFieldType String;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobQueryArrowFieldType Double;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlobQueryArrowFieldType Decimal;
    };
    struct BlobQueryArrowField final
    {
      BlobQueryArrowFieldType Type;
      Nullable<std::string> Name;
      Nullable<std::int32_t> Precision;
      Nullable<std::int32_t> Scale;
    };
    namespace _detail {
      struct ArrowConfiguration final
      {
        std::vector<BlobQueryArrowField> Schema;
      };
      struct ParquetConfiguration final
      {
      };
      struct QueryFormat final
      {
        QueryFormatType Type;
        Nullable<_detail::DelimitedTextConfiguration> DelimitedTextConfiguration;
        Nullable<_detail::JsonTextConfiguration> JsonTextConfiguration;
        Nullable<_detail::ArrowConfiguration> ArrowConfiguration;
        Nullable<ParquetConfiguration> ParquetTextConfiguration;
      };
      struct QuerySerialization final
      {
        QueryFormat Format;
      };
      struct QueryRequest final
      {
        QueryRequestQueryType QueryType;
        std::string Expression;
        Nullable<QuerySerialization> InputSerialization;
        Nullable<QuerySerialization> OutputSerialization;
      };
    } // namespace _detail
    struct QueryBlobResult final
    {
      std::unique_ptr<Core::IO::BodyStream> BodyStream;
      DateTime LastModified;
      Azure::ETag ETag;
      Nullable<LeaseDurationType> LeaseDuration;
      Models::LeaseState LeaseState;
      Models::LeaseStatus LeaseStatus;
      bool IsServerEncrypted = bool();
    };
    struct SetBlobTagsResult final
    {
    };
    struct CreatePageBlobResult final
    {
      bool Created = true;
      Nullable<std::int64_t> SequenceNumber;
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct UploadPagesResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      std::int64_t SequenceNumber = int64_t();
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct ClearPagesResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::int64_t SequenceNumber = int64_t();
    };
    struct UploadPagesFromUriResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      std::int64_t SequenceNumber = int64_t();
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    namespace _detail {
      struct GetPageRangesResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::int64_t BlobSize = std::int64_t();
        std::vector<Core::Http::HttpRange> PageRanges;
        std::vector<Core::Http::HttpRange> ClearRanges;
        std::string ContinuationToken;
      };
      struct GetPageRangesDiffResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::int64_t BlobSize = std::int64_t();
        std::vector<Core::Http::HttpRange> PageRanges;
        std::vector<Core::Http::HttpRange> ClearRanges;
        std::string ContinuationToken;
      };
    } // namespace _detail
    struct ResizePageBlobResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::int64_t SequenceNumber = std::int64_t();
    };
    class SequenceNumberAction final
        : public Core::_internal::ExtendableEnumeration<SequenceNumberAction> {
    public:
      SequenceNumberAction() = default;
      explicit SequenceNumberAction(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static SequenceNumberAction Max;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SequenceNumberAction Update;
      AZ_STORAGE_BLOBS_DLLEXPORT const static SequenceNumberAction Increment;
    };
    struct UpdateSequenceNumberResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::int64_t SequenceNumber = std::int64_t();
    };
    namespace _detail {
      struct StartBlobCopyIncrementalResult final
      {
        Azure::ETag ETag;
        DateTime LastModified;
        std::string CopyId;
        Models::CopyStatus CopyStatus;
        Nullable<std::string> VersionId;
      };
    } // namespace _detail
    struct CreateAppendBlobResult final
    {
      bool Created = true;
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct AppendBlockResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      std::int64_t AppendOffset = std::int64_t();
      std::int32_t CommittedBlockCount = std::int32_t();
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct AppendBlockFromUriResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      std::int64_t AppendOffset = std::int64_t();
      std::int32_t CommittedBlockCount = std::int32_t();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
      bool IsServerEncrypted = bool();
    };
    struct SealAppendBlobResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      bool IsSealed = bool();
    };
    struct UploadBlockBlobResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct UploadBlockBlobFromUriResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct StageBlockResult final
    {
      Nullable<ContentHash> TransactionalContentHash;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct StageBlockFromUriResult final
    {
      Nullable<ContentHash> TransactionalContentHash;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    namespace _detail {
      struct BlockLookupList final
      {
        std::vector<std::string> Committed;
        std::vector<std::string> Uncommitted;
        std::vector<std::string> Latest;
      };
    } // namespace _detail
    struct CommitBlockListResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      Nullable<ContentHash> TransactionalContentHash;
      Nullable<std::string> VersionId;
      bool IsServerEncrypted = bool();
      Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
      Nullable<std::string> EncryptionScope;
    };
    struct BlobBlock final
    {
      std::string Name;
      std::int64_t Size = std::int64_t();
    };
    class BlockListType final : public Core::_internal::ExtendableEnumeration<BlockListType> {
    public:
      BlockListType() = default;
      explicit BlockListType(std::string value) : ExtendableEnumeration(std::move(value)) {}
 
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlockListType Committed;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlockListType Uncommitted;
      AZ_STORAGE_BLOBS_DLLEXPORT const static BlockListType All;
    };
    struct GetBlockListResult final
    {
      Azure::ETag ETag;
      DateTime LastModified;
      std::int64_t BlobSize = 0;
      std::vector<BlobBlock> CommittedBlocks;
      std::vector<BlobBlock> UncommittedBlocks;
    };
  } // namespace Models
  namespace _detail {
    class ServiceClient final {
    public:
      struct SetServicePropertiesOptions final
      {
        Models::BlobServiceProperties BlobServiceProperties;
      };
      static Response<Models::SetServicePropertiesResult> SetProperties(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetServicePropertiesOptions& options,
          const Core::Context& context);
      struct GetServicePropertiesOptions final
      {
      };
      static Response<Models::BlobServiceProperties> GetProperties(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetServicePropertiesOptions& options,
          const Core::Context& context);
      struct GetServiceStatisticsOptions final
      {
      };
      static Response<Models::ServiceStatistics> GetStatistics(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetServiceStatisticsOptions& options,
          const Core::Context& context);
      struct ListServiceBlobContainersOptions final
      {
        Nullable<std::string> Prefix;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
        Nullable<Models::ListBlobContainersIncludeFlags> Include;
      };
      static Response<Models::_detail::ListBlobContainersResult> ListBlobContainers(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ListServiceBlobContainersOptions& options,
          const Core::Context& context);
      struct GetServiceUserDelegationKeyOptions final
      {
        Models::_detail::KeyInfo KeyInfo;
      };
      static Response<Models::UserDelegationKey> GetUserDelegationKey(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetServiceUserDelegationKeyOptions& options,
          const Core::Context& context);
      struct GetServiceAccountInfoOptions final
      {
      };
      static Response<Models::AccountInfo> GetAccountInfo(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetServiceAccountInfoOptions& options,
          const Core::Context& context);
      struct SubmitServiceBatchOptions final
      {
        std::string MultipartContentType;
      };
      static Response<Models::_detail::SubmitBatchResult> SubmitBatch(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          Core::IO::BodyStream& requestBody,
          const SubmitServiceBatchOptions& options,
          const Core::Context& context);
      struct FindServiceBlobsByTagsOptions final
      {
        Nullable<std::string> Where;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
      };
      static Response<Models::_detail::FindBlobsByTagsResult> FindBlobsByTags(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const FindServiceBlobsByTagsOptions& options,
          const Core::Context& context);
    };
    class BlobContainerClient final {
    public:
      struct CreateBlobContainerOptions final
      {
        std::map<std::string, std::string> Metadata;
        Models::PublicAccessType Access;
        Nullable<std::string> DefaultEncryptionScope;
        Nullable<bool> PreventEncryptionScopeOverride;
      };
      static Response<Models::CreateBlobContainerResult> Create(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const CreateBlobContainerOptions& options,
          const Core::Context& context);
      struct GetBlobContainerPropertiesOptions final
      {
        Nullable<std::string> LeaseId;
      };
      static Response<Models::BlobContainerProperties> GetProperties(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlobContainerPropertiesOptions& options,
          const Core::Context& context);
      struct DeleteBlobContainerOptions final
      {
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::DeleteBlobContainerResult> Delete(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const DeleteBlobContainerOptions& options,
          const Core::Context& context);
      struct SetBlobContainerMetadataOptions final
      {
        Nullable<std::string> LeaseId;
        std::map<std::string, std::string> Metadata;
        Nullable<DateTime> IfModifiedSince;
      };
      static Response<Models::SetBlobContainerMetadataResult> SetMetadata(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobContainerMetadataOptions& options,
          const Core::Context& context);
      struct GetBlobContainerAccessPolicyOptions final
      {
        Nullable<std::string> LeaseId;
      };
      static Response<Models::BlobContainerAccessPolicy> GetAccessPolicy(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlobContainerAccessPolicyOptions& options,
          const Core::Context& context);
      struct SetBlobContainerAccessPolicyOptions final
      {
        std::vector<Models::SignedIdentifier> ContainerAcl;
        Nullable<std::string> LeaseId;
        Models::PublicAccessType Access;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::SetBlobContainerAccessPolicyResult> SetAccessPolicy(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobContainerAccessPolicyOptions& options,
          const Core::Context& context);
      struct UndeleteBlobContainerOptions final
      {
        Nullable<std::string> DeletedContainerName;
        Nullable<std::string> DeletedContainerVersion;
      };
      static Response<Models::_detail::UndeleteBlobContainerResult> Undelete(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const UndeleteBlobContainerOptions& options,
          const Core::Context& context);
      struct RenameBlobContainerOptions final
      {
        std::string SourceContainerName;
        Nullable<std::string> SourceLeaseId;
      };
      static Response<Models::_detail::RenameBlobContainerResult> Rename(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const RenameBlobContainerOptions& options,
          const Core::Context& context);
      struct SubmitBlobContainerBatchOptions final
      {
        std::string MultipartContentType;
      };
      static Response<Models::_detail::SubmitBatchResult> SubmitBatch(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          Core::IO::BodyStream& requestBody,
          const SubmitBlobContainerBatchOptions& options,
          const Core::Context& context);
      struct FindBlobContainerBlobsByTagsOptions final
      {
        Nullable<std::string> Where;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
      };
      static Response<Models::_detail::FindBlobsByTagsResult> FindBlobsByTags(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const FindBlobContainerBlobsByTagsOptions& options,
          const Core::Context& context);
      struct AcquireBlobContainerLeaseOptions final
      {
        Nullable<std::int32_t> Duration;
        Nullable<std::string> ProposedLeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::_detail::AcquireBlobContainerLeaseResult> AcquireLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const AcquireBlobContainerLeaseOptions& options,
          const Core::Context& context);
      struct ReleaseBlobContainerLeaseOptions final
      {
        std::string LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::_detail::ReleaseBlobContainerLeaseResult> ReleaseLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ReleaseBlobContainerLeaseOptions& options,
          const Core::Context& context);
      struct RenewBlobContainerLeaseOptions final
      {
        std::string LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::_detail::RenewBlobContainerLeaseResult> RenewLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const RenewBlobContainerLeaseOptions& options,
          const Core::Context& context);
      struct BreakBlobContainerLeaseOptions final
      {
        Nullable<std::int32_t> BreakPeriod;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::_detail::BreakBlobContainerLeaseResult> BreakLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const BreakBlobContainerLeaseOptions& options,
          const Core::Context& context);
      struct ChangeBlobContainerLeaseOptions final
      {
        std::string LeaseId;
        std::string ProposedLeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
      };
      static Response<Models::_detail::ChangeBlobContainerLeaseResult> ChangeLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ChangeBlobContainerLeaseOptions& options,
          const Core::Context& context);
      struct ListBlobContainerBlobsOptions final
      {
        Nullable<std::string> Prefix;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
        Nullable<Models::ListBlobsIncludeFlags> Include;
        Nullable<std::string> StartFrom;
      };
      static Response<Models::_detail::ListBlobsResult> ListBlobs(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ListBlobContainerBlobsOptions& options,
          const Core::Context& context);
      struct ListBlobContainerBlobsByHierarchyOptions final
      {
        Nullable<std::string> Prefix;
        std::string Delimiter;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
        Nullable<Models::ListBlobsIncludeFlags> Include;
        Nullable<std::string> StartFrom;
        Nullable<std::string> ShowOnly;
      };
      static Response<Models::_detail::ListBlobsByHierarchyResult> ListBlobsByHierarchy(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ListBlobContainerBlobsByHierarchyOptions& options,
          const Core::Context& context);
      struct GetBlobContainerAccountInfoOptions final
      {
      };
      static Response<Models::AccountInfo> GetAccountInfo(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlobContainerAccountInfoOptions& options,
          const Core::Context& context);
    };
    class BlobClient final {
    public:
      struct DownloadBlobOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> VersionId;
        Nullable<std::string> Range;
        Nullable<std::string> LeaseId;
        Nullable<bool> RangeGetContentMD5;
        Nullable<bool> RangeGetContentCRC64;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<bool> UserPrincipalName;
      };
      static Response<Models::DownloadBlobResult> Download(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const DownloadBlobOptions& options,
          const Core::Context& context);
      struct GetBlobPropertiesOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> VersionId;
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<bool> UserPrincipalName;
      };
      static Response<Models::BlobProperties> GetProperties(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlobPropertiesOptions& options,
          const Core::Context& context);
      struct DeleteBlobOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> VersionId;
        Nullable<std::string> LeaseId;
        Nullable<Models::DeleteSnapshotsOption> DeleteSnapshots;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::DeleteBlobResult> Delete(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const DeleteBlobOptions& options,
          const Core::Context& context);
      struct UndeleteBlobOptions final
      {
      };
      static Response<Models::UndeleteBlobResult> Undelete(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const UndeleteBlobOptions& options,
          const Core::Context& context);
      struct SetBlobExpiryOptions final
      {
        Models::ScheduleBlobExpiryOriginType ExpiryOptions;
        Nullable<std::string> ExpiresOn;
      };
      static Response<Models::SetBlobExpiryResult> SetExpiry(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobExpiryOptions& options,
          const Core::Context& context);
      struct SetBlobHttpHeadersOptions final
      {
        std::string BlobCacheControl;
        std::string BlobContentType;
        std::vector<std::uint8_t> BlobContentMD5;
        std::string BlobContentEncoding;
        std::string BlobContentLanguage;
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        std::string BlobContentDisposition;
      };
      static Response<Models::SetBlobHttpHeadersResult> SetHttpHeaders(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobHttpHeadersOptions& options,
          const Core::Context& context);
      struct SetBlobImmutabilityPolicyOptions final
      {
        Nullable<DateTime> IfUnmodifiedSince;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
      };
      static Response<Models::SetBlobImmutabilityPolicyResult> SetImmutabilityPolicy(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobImmutabilityPolicyOptions& options,
          const Core::Context& context);
      struct DeleteBlobImmutabilityPolicyOptions final
      {
      };
      static Response<Models::DeleteBlobImmutabilityPolicyResult> DeleteImmutabilityPolicy(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const DeleteBlobImmutabilityPolicyOptions& options,
          const Core::Context& context);
      struct SetBlobLegalHoldOptions final
      {
        bool LegalHold = bool();
      };
      static Response<Models::SetBlobLegalHoldResult> SetLegalHold(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobLegalHoldOptions& options,
          const Core::Context& context);
      struct SetBlobMetadataOptions final
      {
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::SetBlobMetadataResult> SetMetadata(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobMetadataOptions& options,
          const Core::Context& context);
      struct AcquireBlobLeaseOptions final
      {
        Nullable<std::int32_t> Duration;
        Nullable<std::string> ProposedLeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::_detail::AcquireBlobLeaseResult> AcquireLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const AcquireBlobLeaseOptions& options,
          const Core::Context& context);
      struct ReleaseBlobLeaseOptions final
      {
        std::string LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::_detail::ReleaseBlobLeaseResult> ReleaseLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ReleaseBlobLeaseOptions& options,
          const Core::Context& context);
      struct RenewBlobLeaseOptions final
      {
        std::string LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::_detail::RenewBlobLeaseResult> RenewLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const RenewBlobLeaseOptions& options,
          const Core::Context& context);
      struct ChangeBlobLeaseOptions final
      {
        std::string LeaseId;
        std::string ProposedLeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::_detail::ChangeBlobLeaseResult> ChangeLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ChangeBlobLeaseOptions& options,
          const Core::Context& context);
      struct BreakBlobLeaseOptions final
      {
        Nullable<std::int32_t> BreakPeriod;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::_detail::BreakBlobLeaseResult> BreakLease(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const BreakBlobLeaseOptions& options,
          const Core::Context& context);
      struct CreateBlobSnapshotOptions final
      {
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> LeaseId;
      };
      static Response<Models::CreateBlobSnapshotResult> CreateSnapshot(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const CreateBlobSnapshotOptions& options,
          const Core::Context& context);
      struct StartBlobCopyFromUriOptions final
      {
        Nullable<std::string> SourceLeaseId;
        std::map<std::string, std::string> Metadata;
        Nullable<Models::AccessTier> Tier;
        Nullable<Models::RehydratePriority> RehydratePriority;
        Nullable<DateTime> SourceIfModifiedSince;
        Nullable<DateTime> SourceIfUnmodifiedSince;
        ETag SourceIfMatch;
        ETag SourceIfNoneMatch;
        Nullable<std::string> SourceIfTags;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        std::string CopySource;
        Nullable<std::string> LeaseId;
        Nullable<std::string> BlobTagsString;
        Nullable<bool> SealBlob;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
        Nullable<bool> LegalHold;
      };
      static Response<Models::_detail::StartBlobCopyFromUriResult> StartCopyFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const StartBlobCopyFromUriOptions& options,
          const Core::Context& context);
      struct CopyBlobFromUriOptions final
      {
        std::map<std::string, std::string> Metadata;
        Nullable<Models::AccessTier> Tier;
        Nullable<DateTime> SourceIfModifiedSince;
        Nullable<DateTime> SourceIfUnmodifiedSince;
        ETag SourceIfMatch;
        ETag SourceIfNoneMatch;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        std::string CopySource;
        Nullable<std::string> LeaseId;
        Nullable<std::vector<std::uint8_t>> SourceContentMD5;
        Nullable<std::string> BlobTagsString;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
        Nullable<bool> LegalHold;
        Nullable<std::string> CopySourceAuthorization;
        Nullable<std::string> EncryptionScope;
        Nullable<Models::BlobCopySourceTagsMode> CopySourceTags;
        Nullable<Models::FileShareTokenIntent> FileRequestIntent;
        Nullable<std::vector<std::uint8_t>> SourceContentcrc64;
      };
      static Response<Models::CopyBlobFromUriResult> CopyFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const CopyBlobFromUriOptions& options,
          const Core::Context& context);
      struct AbortBlobCopyFromUriOptions final
      {
        std::string CopyId;
        Nullable<std::string> LeaseId;
      };
      static Response<Models::AbortBlobCopyFromUriResult> AbortCopyFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const AbortBlobCopyFromUriOptions& options,
          const Core::Context& context);
      struct SetBlobTierOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> VersionId;
        Models::AccessTier Tier;
        Nullable<Models::RehydratePriority> RehydratePriority;
        Nullable<std::string> LeaseId;
        Nullable<std::string> IfTags;
      };
      static Response<Models::SetBlobAccessTierResult> SetTier(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobTierOptions& options,
          const Core::Context& context);
      struct GetBlobAccountInfoOptions final
      {
      };
      static Response<Models::AccountInfo> GetAccountInfo(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlobAccountInfoOptions& options,
          const Core::Context& context);
      struct QueryBlobOptions final
      {
        Models::_detail::QueryRequest QueryRequest;
        Nullable<std::string> Snapshot;
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> EncryptionScope;
      };
      static Response<Models::QueryBlobResult> Query(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const QueryBlobOptions& options,
          const Core::Context& context);
      struct GetBlobTagsOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> VersionId;
        Nullable<std::string> IfTags;
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
      };
      static Response<std::map<std::string, std::string>> GetTags(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlobTagsOptions& options,
          const Core::Context& context);
      struct SetBlobTagsOptions final
      {
        std::map<std::string, std::string> Tags;
        Nullable<std::string> VersionId;
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        Nullable<std::vector<std::uint8_t>> TransactionalContentCrc64;
        Nullable<std::string> IfTags;
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
      };
      static Response<Models::SetBlobTagsResult> SetTags(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SetBlobTagsOptions& options,
          const Core::Context& context);
    };
    class PageBlobClient final {
    public:
      struct CreatePageBlobOptions final
      {
        Nullable<Models::AccessTier> Tier;
        std::string BlobContentType;
        std::string BlobContentEncoding;
        std::string BlobContentLanguage;
        std::vector<std::uint8_t> BlobContentMD5;
        std::string BlobCacheControl;
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> LeaseId;
        std::string BlobContentDisposition;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        std::int64_t BlobContentLength = std::int64_t();
        Nullable<std::int64_t> BlobSequenceNumber;
        Nullable<std::string> BlobTagsString;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
        Nullable<bool> LegalHold;
      };
      static Response<Models::CreatePageBlobResult> Create(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const CreatePageBlobOptions& options,
          const Core::Context& context);
      struct UploadPageBlobPagesOptions final
      {
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        Nullable<std::vector<std::uint8_t>> TransactionalContentCrc64;
        Nullable<std::string> Range;
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<std::int64_t> IfSequenceNumberLessThanOrEqualTo;
        Nullable<std::int64_t> IfSequenceNumberLessThan;
        Nullable<std::int64_t> IfSequenceNumberEqualTo;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::UploadPagesResult> UploadPages(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          Core::IO::BodyStream& requestBody,
          const UploadPageBlobPagesOptions& options,
          const Core::Context& context);
      struct ClearPageBlobPagesOptions final
      {
        Nullable<std::string> Range;
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<std::int64_t> IfSequenceNumberLessThanOrEqualTo;
        Nullable<std::int64_t> IfSequenceNumberLessThan;
        Nullable<std::int64_t> IfSequenceNumberEqualTo;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::ClearPagesResult> ClearPages(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ClearPageBlobPagesOptions& options,
          const Core::Context& context);
      struct UploadPageBlobPagesFromUriOptions final
      {
        std::string SourceUrl;
        std::string SourceRange;
        Nullable<std::vector<std::uint8_t>> SourceContentMD5;
        Nullable<std::vector<std::uint8_t>> SourceContentcrc64;
        std::string Range;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<std::string> LeaseId;
        Nullable<std::int64_t> IfSequenceNumberLessThanOrEqualTo;
        Nullable<std::int64_t> IfSequenceNumberLessThan;
        Nullable<std::int64_t> IfSequenceNumberEqualTo;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<DateTime> SourceIfModifiedSince;
        Nullable<DateTime> SourceIfUnmodifiedSince;
        ETag SourceIfMatch;
        ETag SourceIfNoneMatch;
        Nullable<std::string> CopySourceAuthorization;
        Nullable<Models::FileShareTokenIntent> FileRequestIntent;
      };
      static Response<Models::UploadPagesFromUriResult> UploadPagesFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const UploadPageBlobPagesFromUriOptions& options,
          const Core::Context& context);
      struct GetPageBlobPageRangesOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> Range;
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
      };
      static Response<Models::_detail::GetPageRangesResult> GetPageRanges(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetPageBlobPageRangesOptions& options,
          const Core::Context& context);
      struct GetPageBlobPageRangesDiffOptions final
      {
        Nullable<std::string> Snapshot;
        Nullable<std::string> Prevsnapshot;
        Nullable<std::string> PrevSnapshotUrl;
        Nullable<std::string> Range;
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> Marker;
        Nullable<std::int32_t> MaxResults;
      };
      static Response<Models::_detail::GetPageRangesDiffResult> GetPageRangesDiff(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetPageBlobPageRangesDiffOptions& options,
          const Core::Context& context);
      struct ResizePageBlobOptions final
      {
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        std::int64_t BlobContentLength = std::int64_t();
      };
      static Response<Models::ResizePageBlobResult> Resize(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const ResizePageBlobOptions& options,
          const Core::Context& context);
      struct UpdatePageBlobSequenceNumberOptions final
      {
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Models::SequenceNumberAction SequenceNumberAction;
        Nullable<std::int64_t> BlobSequenceNumber;
      };
      static Response<Models::UpdateSequenceNumberResult> UpdateSequenceNumber(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const UpdatePageBlobSequenceNumberOptions& options,
          const Core::Context& context);
      struct StartPageBlobCopyIncrementalOptions final
      {
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        std::string CopySource;
      };
      static Response<Models::_detail::StartBlobCopyIncrementalResult> StartCopyIncremental(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const StartPageBlobCopyIncrementalOptions& options,
          const Core::Context& context);
    };
    class AppendBlobClient final {
    public:
      struct CreateAppendBlobOptions final
      {
        std::string BlobContentType;
        std::string BlobContentEncoding;
        std::string BlobContentLanguage;
        std::vector<std::uint8_t> BlobContentMD5;
        std::string BlobCacheControl;
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> LeaseId;
        std::string BlobContentDisposition;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> BlobTagsString;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
        Nullable<bool> LegalHold;
      };
      static Response<Models::CreateAppendBlobResult> Create(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const CreateAppendBlobOptions& options,
          const Core::Context& context);
      struct AppendAppendBlobBlockOptions final
      {
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        Nullable<std::vector<std::uint8_t>> TransactionalContentCrc64;
        Nullable<std::string> LeaseId;
        Nullable<std::int64_t> MaxSize;
        Nullable<std::int64_t> AppendPosition;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
      };
      static Response<Models::AppendBlockResult> AppendBlock(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          Core::IO::BodyStream& requestBody,
          const AppendAppendBlobBlockOptions& options,
          const Core::Context& context);
      struct AppendAppendBlobBlockFromUriOptions final
      {
        std::string SourceUrl;
        Nullable<std::string> SourceRange;
        Nullable<std::vector<std::uint8_t>> SourceContentMD5;
        Nullable<std::vector<std::uint8_t>> SourceContentcrc64;
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<std::string> LeaseId;
        Nullable<std::int64_t> MaxSize;
        Nullable<std::int64_t> AppendPosition;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<DateTime> SourceIfModifiedSince;
        Nullable<DateTime> SourceIfUnmodifiedSince;
        ETag SourceIfMatch;
        ETag SourceIfNoneMatch;
        Nullable<std::string> CopySourceAuthorization;
        Nullable<Models::FileShareTokenIntent> FileRequestIntent;
      };
      static Response<Models::AppendBlockFromUriResult> AppendBlockFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const AppendAppendBlobBlockFromUriOptions& options,
          const Core::Context& context);
      struct SealAppendBlobOptions final
      {
        Nullable<std::string> LeaseId;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::int64_t> AppendPosition;
      };
      static Response<Models::SealAppendBlobResult> Seal(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const SealAppendBlobOptions& options,
          const Core::Context& context);
    };
    class BlockBlobClient final {
    public:
      struct UploadBlockBlobOptions final
      {
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        std::string BlobContentType;
        std::string BlobContentEncoding;
        std::string BlobContentLanguage;
        std::vector<std::uint8_t> BlobContentMD5;
        std::string BlobCacheControl;
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> LeaseId;
        std::string BlobContentDisposition;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<Models::AccessTier> Tier;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> BlobTagsString;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
        Nullable<bool> LegalHold;
        Nullable<std::vector<std::uint8_t>> TransactionalContentCrc64;
      };
      static Response<Models::UploadBlockBlobResult> Upload(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          Core::IO::BodyStream& requestBody,
          const UploadBlockBlobOptions& options,
          const Core::Context& context);
      struct UploadBlockBlobFromUriOptions final
      {
        std::string BlobContentType;
        std::string BlobContentEncoding;
        std::string BlobContentLanguage;
        std::vector<std::uint8_t> BlobContentMD5;
        std::string BlobCacheControl;
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> LeaseId;
        std::string BlobContentDisposition;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<Models::AccessTier> Tier;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<DateTime> SourceIfModifiedSince;
        Nullable<DateTime> SourceIfUnmodifiedSince;
        ETag SourceIfMatch;
        ETag SourceIfNoneMatch;
        Nullable<std::string> SourceIfTags;
        Nullable<std::vector<std::uint8_t>> SourceContentMD5;
        Nullable<std::string> BlobTagsString;
        std::string CopySource;
        Nullable<bool> CopySourceBlobProperties;
        Nullable<std::string> CopySourceAuthorization;
        Nullable<Models::BlobCopySourceTagsMode> CopySourceTags;
        Nullable<Models::FileShareTokenIntent> FileRequestIntent;
        Nullable<std::vector<std::uint8_t>> SourceContentcrc64;
      };
      static Response<Models::UploadBlockBlobFromUriResult> UploadFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const UploadBlockBlobFromUriOptions& options,
          const Core::Context& context);
      struct StageBlockBlobBlockOptions final
      {
        std::string BlockId;
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        Nullable<std::vector<std::uint8_t>> TransactionalContentCrc64;
        Nullable<std::string> LeaseId;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
      };
      static Response<Models::StageBlockResult> StageBlock(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          Core::IO::BodyStream& requestBody,
          const StageBlockBlobBlockOptions& options,
          const Core::Context& context);
      struct StageBlockBlobBlockFromUriOptions final
      {
        std::string BlockId;
        std::string SourceUrl;
        Nullable<std::string> SourceRange;
        Nullable<std::vector<std::uint8_t>> SourceContentMD5;
        Nullable<std::vector<std::uint8_t>> SourceContentcrc64;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<std::string> LeaseId;
        Nullable<DateTime> SourceIfModifiedSince;
        Nullable<DateTime> SourceIfUnmodifiedSince;
        ETag SourceIfMatch;
        ETag SourceIfNoneMatch;
        Nullable<std::string> CopySourceAuthorization;
        Nullable<Models::FileShareTokenIntent> FileRequestIntent;
      };
      static Response<Models::StageBlockFromUriResult> StageBlockFromUri(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const StageBlockBlobBlockFromUriOptions& options,
          const Core::Context& context);
      struct CommitBlockBlobBlockListOptions final
      {
        Models::_detail::BlockLookupList Blocks;
        std::string BlobCacheControl;
        std::string BlobContentType;
        std::string BlobContentEncoding;
        std::string BlobContentLanguage;
        std::vector<std::uint8_t> BlobContentMD5;
        Nullable<std::vector<std::uint8_t>> TransactionalContentMD5;
        Nullable<std::vector<std::uint8_t>> TransactionalContentCrc64;
        std::map<std::string, std::string> Metadata;
        Nullable<std::string> LeaseId;
        std::string BlobContentDisposition;
        Nullable<std::string> EncryptionKey;
        Nullable<std::vector<std::uint8_t>> EncryptionKeySha256;
        Nullable<std::string> EncryptionAlgorithm;
        Nullable<std::string> EncryptionScope;
        Nullable<Models::AccessTier> Tier;
        Nullable<DateTime> IfModifiedSince;
        Nullable<DateTime> IfUnmodifiedSince;
        ETag IfMatch;
        ETag IfNoneMatch;
        Nullable<std::string> IfTags;
        Nullable<std::string> BlobTagsString;
        Nullable<DateTime> ImmutabilityPolicyExpiry;
        Nullable<Models::BlobImmutabilityPolicyMode> ImmutabilityPolicyMode;
        Nullable<bool> LegalHold;
      };
      static Response<Models::CommitBlockListResult> CommitBlockList(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const CommitBlockBlobBlockListOptions& options,
          const Core::Context& context);
      struct GetBlockBlobBlockListOptions final
      {
        Nullable<std::string> Snapshot;
        Models::BlockListType ListType;
        Nullable<std::string> LeaseId;
        Nullable<std::string> IfTags;
      };
      static Response<Models::GetBlockListResult> GetBlockList(
          Core::Http::_internal::HttpPipeline& pipeline,
          const Core::Url& url,
          const GetBlockBlobBlockListOptions& options,
          const Core::Context& context);
    };
  } // namespace _detail
}}} // namespace Azure::Storage::Blobs