diff --git a/sdk/storage/azure-storage-blobs/CHANGELOG.md b/sdk/storage/azure-storage-blobs/CHANGELOG.md
index 3755f555e..4d780613c 100644
--- a/sdk/storage/azure-storage-blobs/CHANGELOG.md
+++ b/sdk/storage/azure-storage-blobs/CHANGELOG.md
@@ -29,6 +29,7 @@
 - Removed `TagValue` from `FilterBlobItem`, removed `Where` from `FindBlobsByTagsSinglePageResult`.
 - Type for ETag was changed to `Azure::Core::ETag`.
 - Removed `BlobPrefix` struct, use `std::string` instead.
+- Refined `DownloadBlobResult` and `DownloadBlobToResult`.
 
 ## 12.0.0-beta.6 (2020-01-14)
 
diff --git a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_responses.hpp b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_responses.hpp
index f4939a823..3a6085c9c 100644
--- a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_responses.hpp
+++ b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_responses.hpp
@@ -21,39 +21,11 @@ namespace Azure { namespace Storage { namespace Blobs {
 
     struct DownloadBlobToResult
     {
-      Azure::Core::ETag ETag;
-      Azure::Core::DateTime LastModified;
-      Azure::Core::DateTime CreatedOn;
-      Azure::Core::Nullable<Azure::Core::DateTime> ExpiresOn;
-      Azure::Core::Nullable<Azure::Core::DateTime> LastAccessedOn;
+      Models::BlobType BlobType;
       Azure::Core::Http::Range ContentRange;
       int64_t BlobSize = 0;
-      BlobHttpHeaders HttpHeaders;
-      Storage::Metadata Metadata;
-      Azure::Core::Nullable<int64_t> SequenceNumber; // only for page blob
-      Azure::Core::Nullable<int64_t> CommittedBlockCount; // only for append blob
-      Azure::Core::Nullable<bool> IsSealed; // only for append blob
-      Models::BlobType BlobType;
       Azure::Core::Nullable<ContentHash> TransactionalContentHash; // hash for the downloaded range
-      Azure::Core::Nullable<BlobLeaseDurationType> LeaseDuration;
-      Azure::Core::Nullable<BlobLeaseState> LeaseState;
-      Azure::Core::Nullable<BlobLeaseStatus> LeaseStatus;
-      bool IsServerEncrypted = false;
-      Azure::Core::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
-      Azure::Core::Nullable<std::string> EncryptionScope;
-      Azure::Core::Nullable<std::string>
-          ObjectReplicationDestinationPolicyId; // only valid for replication destination blob
-      std::vector<ObjectReplicationPolicy>
-          ObjectReplicationSourceProperties; // only valid for replication source blob
-      Azure::Core::Nullable<int32_t> TagCount;
-      Azure::Core::Nullable<std::string> CopyId;
-      Azure::Core::Nullable<std::string> CopySource;
-      Azure::Core::Nullable<Models::CopyStatus> CopyStatus;
-      Azure::Core::Nullable<std::string> CopyStatusDescription;
-      Azure::Core::Nullable<std::string> CopyProgress;
-      Azure::Core::Nullable<Azure::Core::DateTime> CopyCompletedOn;
-      Azure::Core::Nullable<std::string> VersionId;
-      Azure::Core::Nullable<bool> IsCurrentVersion;
+      DownloadBlobDetails Details;
     };
 
     using UploadBlockBlobFromResult = UploadBlockBlobResult;
diff --git a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp
index 485618d74..c78d4b822 100644
--- a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp
+++ b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp
@@ -1038,24 +1038,18 @@ namespace Azure { namespace Storage { namespace Blobs {
           ObjectReplicationSourceProperties; // only valid for replication source blob
     }; // struct BlobItem
 
-    struct DownloadBlobResult
+    struct DownloadBlobDetails
     {
-      std::string RequestId;
-      std::unique_ptr<Azure::Core::Http::BodyStream> BodyStream;
       Azure::Core::ETag ETag;
       Azure::Core::DateTime LastModified;
       Azure::Core::DateTime CreatedOn;
       Azure::Core::Nullable<Azure::Core::DateTime> ExpiresOn;
       Azure::Core::Nullable<Azure::Core::DateTime> LastAccessedOn;
-      Azure::Core::Http::Range ContentRange;
-      int64_t BlobSize = 0;
       BlobHttpHeaders HttpHeaders;
       Storage::Metadata Metadata;
       Azure::Core::Nullable<int64_t> SequenceNumber; // only for page blob
       Azure::Core::Nullable<int64_t> CommittedBlockCount; // only for append blob
       Azure::Core::Nullable<bool> IsSealed; // only for append blob
-      Models::BlobType BlobType;
-      Azure::Core::Nullable<ContentHash> TransactionalContentHash; // hash for the downloaded range
       Azure::Core::Nullable<BlobLeaseDurationType> LeaseDuration;
       Azure::Core::Nullable<BlobLeaseState> LeaseState;
       Azure::Core::Nullable<BlobLeaseStatus> LeaseStatus;
@@ -1075,7 +1069,7 @@ namespace Azure { namespace Storage { namespace Blobs {
       Azure::Core::Nullable<Azure::Core::DateTime> CopyCompletedOn;
       Azure::Core::Nullable<std::string> VersionId;
       Azure::Core::Nullable<bool> IsCurrentVersion;
-    }; // struct DownloadBlobResult
+    }; // struct DownloadBlobDetails
 
     struct GetBlobPropertiesResult
     {
@@ -1120,6 +1114,17 @@ namespace Azure { namespace Storage { namespace Blobs {
       Azure::Core::Nullable<bool> IsCurrentVersion;
     }; // struct GetBlobPropertiesResult
 
+    struct DownloadBlobResult
+    {
+      std::string RequestId;
+      std::unique_ptr<Azure::Core::Http::BodyStream> BodyStream;
+      Azure::Core::Http::Range ContentRange;
+      int64_t BlobSize = 0;
+      Models::BlobType BlobType;
+      Azure::Core::Nullable<ContentHash> TransactionalContentHash; // hash for the downloaded range
+      DownloadBlobDetails Details;
+    }; // struct DownloadBlobResult
+
     struct ListBlobsByHierarchySinglePageResult
     {
       std::string RequestId;
@@ -4924,10 +4929,6 @@ namespace Azure { namespace Storage { namespace Blobs {
           }
           response.BodyStream = httpResponse.GetBodyStream();
           response.RequestId = httpResponse.GetHeaders().at("x-ms-request-id");
-          response.ETag = Azure::Core::ETag(httpResponse.GetHeaders().at("etag"));
-          response.LastModified = Azure::Core::DateTime::Parse(
-              httpResponse.GetHeaders().at("last-modified"),
-              Azure::Core::DateTime::DateFormat::Rfc1123);
           {
             const auto& headers = httpResponse.GetHeaders();
             auto content_md5_iterator = headers.find("content-md5");
@@ -4947,99 +4948,7 @@ namespace Azure { namespace Storage { namespace Blobs {
               response.TransactionalContentHash = std::move(hash);
             }
           }
-          auto content_type__iterator = httpResponse.GetHeaders().find("content-type");
-          if (content_type__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.ContentType = content_type__iterator->second;
-          }
-          auto content_encoding__iterator = httpResponse.GetHeaders().find("content-encoding");
-          if (content_encoding__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.ContentEncoding = content_encoding__iterator->second;
-          }
-          auto content_language__iterator = httpResponse.GetHeaders().find("content-language");
-          if (content_language__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.ContentLanguage = content_language__iterator->second;
-          }
-          auto cache_control__iterator = httpResponse.GetHeaders().find("cache-control");
-          if (cache_control__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.CacheControl = cache_control__iterator->second;
-          }
-          auto content_md5__iterator = httpResponse.GetHeaders().find("content-md5");
-          if (content_md5__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.ContentHash.Value
-                = Azure::Core::Base64Decode(content_md5__iterator->second);
-          }
-          auto x_ms_blob_content_md5__iterator
-              = httpResponse.GetHeaders().find("x-ms-blob-content-md5");
-          if (x_ms_blob_content_md5__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.ContentHash.Value
-                = Azure::Core::Base64Decode(x_ms_blob_content_md5__iterator->second);
-          }
-          auto content_disposition__iterator
-              = httpResponse.GetHeaders().find("content-disposition");
-          if (content_disposition__iterator != httpResponse.GetHeaders().end())
-          {
-            response.HttpHeaders.ContentDisposition = content_disposition__iterator->second;
-          }
-          for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-");
-               i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-";
-               ++i)
-          {
-            response.Metadata.emplace(i->first.substr(10), i->second);
-          }
-          response.IsServerEncrypted
-              = httpResponse.GetHeaders().at("x-ms-server-encrypted") == "true";
-          auto x_ms_encryption_key_sha256__iterator
-              = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256");
-          if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
-          {
-            response.EncryptionKeySha256
-                = Azure::Core::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
-          }
-          auto x_ms_encryption_scope__iterator
-              = httpResponse.GetHeaders().find("x-ms-encryption-scope");
-          if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
-          {
-            response.EncryptionScope = x_ms_encryption_scope__iterator->second;
-          }
-          auto x_ms_lease_status__iterator = httpResponse.GetHeaders().find("x-ms-lease-status");
-          if (x_ms_lease_status__iterator != httpResponse.GetHeaders().end())
-          {
-            response.LeaseStatus = BlobLeaseStatus(x_ms_lease_status__iterator->second);
-          }
-          auto x_ms_lease_state__iterator = httpResponse.GetHeaders().find("x-ms-lease-state");
-          if (x_ms_lease_state__iterator != httpResponse.GetHeaders().end())
-          {
-            response.LeaseState = BlobLeaseState(x_ms_lease_state__iterator->second);
-          }
-          auto x_ms_lease_duration__iterator
-              = httpResponse.GetHeaders().find("x-ms-lease-duration");
-          if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
-          {
-            response.LeaseDuration = BlobLeaseDurationType(x_ms_lease_duration__iterator->second);
-          }
-          response.CreatedOn = Azure::Core::DateTime::Parse(
-              httpResponse.GetHeaders().at("x-ms-creation-time"),
-              Azure::Core::DateTime::DateFormat::Rfc1123);
-          auto x_ms_expiry_time__iterator = httpResponse.GetHeaders().find("x-ms-expiry-time");
-          if (x_ms_expiry_time__iterator != httpResponse.GetHeaders().end())
-          {
-            response.ExpiresOn = Azure::Core::DateTime::Parse(
-                x_ms_expiry_time__iterator->second, Azure::Core::DateTime::DateFormat::Rfc1123);
-          }
-          auto x_ms_last_access_time__iterator
-              = httpResponse.GetHeaders().find("x-ms-last-access-time");
-          if (x_ms_last_access_time__iterator != httpResponse.GetHeaders().end())
-          {
-            response.LastAccessedOn = Azure::Core::DateTime::Parse(
-                x_ms_last_access_time__iterator->second,
-                Azure::Core::DateTime::DateFormat::Rfc1123);
-          }
+          response.BlobType = BlobType(httpResponse.GetHeaders().at("x-ms-blob-type"));
           auto content_range_iterator = httpResponse.GetHeaders().find("content-range");
           if (content_range_iterator != httpResponse.GetHeaders().end())
           {
@@ -5069,29 +4978,128 @@ namespace Azure { namespace Storage { namespace Blobs {
           {
             response.BlobSize = std::stoll(httpResponse.GetHeaders().at("content-length"));
           }
+          response.Details.ETag = Azure::Core::ETag(httpResponse.GetHeaders().at("etag"));
+          response.Details.LastModified = Azure::Core::DateTime::Parse(
+              httpResponse.GetHeaders().at("last-modified"),
+              Azure::Core::DateTime::DateFormat::Rfc1123);
+          auto content_type__iterator = httpResponse.GetHeaders().find("content-type");
+          if (content_type__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.ContentType = content_type__iterator->second;
+          }
+          auto content_encoding__iterator = httpResponse.GetHeaders().find("content-encoding");
+          if (content_encoding__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.ContentEncoding = content_encoding__iterator->second;
+          }
+          auto content_language__iterator = httpResponse.GetHeaders().find("content-language");
+          if (content_language__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.ContentLanguage = content_language__iterator->second;
+          }
+          auto cache_control__iterator = httpResponse.GetHeaders().find("cache-control");
+          if (cache_control__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.CacheControl = cache_control__iterator->second;
+          }
+          auto content_md5__iterator = httpResponse.GetHeaders().find("content-md5");
+          if (content_md5__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.ContentHash.Value
+                = Azure::Core::Base64Decode(content_md5__iterator->second);
+          }
+          auto x_ms_blob_content_md5__iterator
+              = httpResponse.GetHeaders().find("x-ms-blob-content-md5");
+          if (x_ms_blob_content_md5__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.ContentHash.Value
+                = Azure::Core::Base64Decode(x_ms_blob_content_md5__iterator->second);
+          }
+          auto content_disposition__iterator
+              = httpResponse.GetHeaders().find("content-disposition");
+          if (content_disposition__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.HttpHeaders.ContentDisposition = content_disposition__iterator->second;
+          }
+          for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-");
+               i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-";
+               ++i)
+          {
+            response.Details.Metadata.emplace(i->first.substr(10), i->second);
+          }
+          response.Details.IsServerEncrypted
+              = httpResponse.GetHeaders().at("x-ms-server-encrypted") == "true";
+          auto x_ms_encryption_key_sha256__iterator
+              = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256");
+          if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.EncryptionKeySha256
+                = Azure::Core::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
+          }
+          auto x_ms_encryption_scope__iterator
+              = httpResponse.GetHeaders().find("x-ms-encryption-scope");
+          if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.EncryptionScope = x_ms_encryption_scope__iterator->second;
+          }
+          auto x_ms_lease_status__iterator = httpResponse.GetHeaders().find("x-ms-lease-status");
+          if (x_ms_lease_status__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.LeaseStatus = BlobLeaseStatus(x_ms_lease_status__iterator->second);
+          }
+          auto x_ms_lease_state__iterator = httpResponse.GetHeaders().find("x-ms-lease-state");
+          if (x_ms_lease_state__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.LeaseState = BlobLeaseState(x_ms_lease_state__iterator->second);
+          }
+          auto x_ms_lease_duration__iterator
+              = httpResponse.GetHeaders().find("x-ms-lease-duration");
+          if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.LeaseDuration
+                = BlobLeaseDurationType(x_ms_lease_duration__iterator->second);
+          }
+          response.Details.CreatedOn = Azure::Core::DateTime::Parse(
+              httpResponse.GetHeaders().at("x-ms-creation-time"),
+              Azure::Core::DateTime::DateFormat::Rfc1123);
+          auto x_ms_expiry_time__iterator = httpResponse.GetHeaders().find("x-ms-expiry-time");
+          if (x_ms_expiry_time__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.ExpiresOn = Azure::Core::DateTime::Parse(
+                x_ms_expiry_time__iterator->second, Azure::Core::DateTime::DateFormat::Rfc1123);
+          }
+          auto x_ms_last_access_time__iterator
+              = httpResponse.GetHeaders().find("x-ms-last-access-time");
+          if (x_ms_last_access_time__iterator != httpResponse.GetHeaders().end())
+          {
+            response.Details.LastAccessedOn = Azure::Core::DateTime::Parse(
+                x_ms_last_access_time__iterator->second,
+                Azure::Core::DateTime::DateFormat::Rfc1123);
+          }
           auto x_ms_blob_sequence_number__iterator
               = httpResponse.GetHeaders().find("x-ms-blob-sequence-number");
           if (x_ms_blob_sequence_number__iterator != httpResponse.GetHeaders().end())
           {
-            response.SequenceNumber = std::stoll(x_ms_blob_sequence_number__iterator->second);
+            response.Details.SequenceNumber
+                = std::stoll(x_ms_blob_sequence_number__iterator->second);
           }
           auto x_ms_blob_committed_block_count__iterator
               = httpResponse.GetHeaders().find("x-ms-blob-committed-block-count");
           if (x_ms_blob_committed_block_count__iterator != httpResponse.GetHeaders().end())
           {
-            response.CommittedBlockCount
+            response.Details.CommittedBlockCount
                 = std::stoll(x_ms_blob_committed_block_count__iterator->second);
           }
           auto x_ms_blob_sealed__iterator = httpResponse.GetHeaders().find("x-ms-blob-sealed");
           if (x_ms_blob_sealed__iterator != httpResponse.GetHeaders().end())
           {
-            response.IsSealed = x_ms_blob_sealed__iterator->second == "true";
+            response.Details.IsSealed = x_ms_blob_sealed__iterator->second == "true";
           }
-          response.BlobType = BlobType(httpResponse.GetHeaders().at("x-ms-blob-type"));
           auto x_ms_or_policy_id__iterator = httpResponse.GetHeaders().find("x-ms-or-policy-id");
           if (x_ms_or_policy_id__iterator != httpResponse.GetHeaders().end())
           {
-            response.ObjectReplicationDestinationPolicyId = x_ms_or_policy_id__iterator->second;
+            response.Details.ObjectReplicationDestinationPolicyId
+                = x_ms_or_policy_id__iterator->second;
           }
           {
             std::map<std::string, std::vector<ObjectReplicationRule>> orPropertiesMap;
@@ -5119,58 +5127,58 @@ namespace Azure { namespace Storage { namespace Blobs {
               ObjectReplicationPolicy policy;
               policy.PolicyId = property.first;
               policy.Rules = std::move(property.second);
-              response.ObjectReplicationSourceProperties.emplace_back(std::move(policy));
+              response.Details.ObjectReplicationSourceProperties.emplace_back(std::move(policy));
             }
           }
           auto x_ms_tag_count__iterator = httpResponse.GetHeaders().find("x-ms-tag-count");
           if (x_ms_tag_count__iterator != httpResponse.GetHeaders().end())
           {
-            response.TagCount = std::stoi(x_ms_tag_count__iterator->second);
+            response.Details.TagCount = std::stoi(x_ms_tag_count__iterator->second);
           }
           auto x_ms_copy_id__iterator = httpResponse.GetHeaders().find("x-ms-copy-id");
           if (x_ms_copy_id__iterator != httpResponse.GetHeaders().end())
           {
-            response.CopyId = x_ms_copy_id__iterator->second;
+            response.Details.CopyId = x_ms_copy_id__iterator->second;
           }
           auto x_ms_copy_source__iterator = httpResponse.GetHeaders().find("x-ms-copy-source");
           if (x_ms_copy_source__iterator != httpResponse.GetHeaders().end())
           {
-            response.CopySource = x_ms_copy_source__iterator->second;
+            response.Details.CopySource = x_ms_copy_source__iterator->second;
           }
           auto x_ms_copy_status__iterator = httpResponse.GetHeaders().find("x-ms-copy-status");
           if (x_ms_copy_status__iterator != httpResponse.GetHeaders().end())
           {
-            response.CopyStatus = CopyStatus(x_ms_copy_status__iterator->second);
+            response.Details.CopyStatus = CopyStatus(x_ms_copy_status__iterator->second);
           }
           auto x_ms_copy_status_description__iterator
               = httpResponse.GetHeaders().find("x-ms-copy-status-description");
           if (x_ms_copy_status_description__iterator != httpResponse.GetHeaders().end())
           {
-            response.CopyStatusDescription = x_ms_copy_status_description__iterator->second;
+            response.Details.CopyStatusDescription = x_ms_copy_status_description__iterator->second;
           }
           auto x_ms_copy_progress__iterator = httpResponse.GetHeaders().find("x-ms-copy-progress");
           if (x_ms_copy_progress__iterator != httpResponse.GetHeaders().end())
           {
-            response.CopyProgress = x_ms_copy_progress__iterator->second;
+            response.Details.CopyProgress = x_ms_copy_progress__iterator->second;
           }
           auto x_ms_copy_completion_time__iterator
               = httpResponse.GetHeaders().find("x-ms-copy-completion-time");
           if (x_ms_copy_completion_time__iterator != httpResponse.GetHeaders().end())
           {
-            response.CopyCompletedOn = Azure::Core::DateTime::Parse(
+            response.Details.CopyCompletedOn = Azure::Core::DateTime::Parse(
                 x_ms_copy_completion_time__iterator->second,
                 Azure::Core::DateTime::DateFormat::Rfc1123);
           }
           auto x_ms_version_id__iterator = httpResponse.GetHeaders().find("x-ms-version-id");
           if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
           {
-            response.VersionId = x_ms_version_id__iterator->second;
+            response.Details.VersionId = x_ms_version_id__iterator->second;
           }
           auto x_ms_is_current_version__iterator
               = httpResponse.GetHeaders().find("x-ms-is-current-version");
           if (x_ms_is_current_version__iterator != httpResponse.GetHeaders().end())
           {
-            response.IsCurrentVersion = x_ms_is_current_version__iterator->second == "true";
+            response.Details.IsCurrentVersion = x_ms_is_current_version__iterator->second == "true";
           }
           return Azure::Core::Response<DownloadBlobResult>(
               std::move(response), std::move(pHttpResponse));
diff --git a/sdk/storage/azure-storage-blobs/src/blob_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_client.cpp
index 9910cd322..dd9c53292 100644
--- a/sdk/storage/azure-storage-blobs/src/blob_client.cpp
+++ b/sdk/storage/azure-storage-blobs/src/blob_client.cpp
@@ -180,7 +180,7 @@ namespace Azure { namespace Storage { namespace Blobs {
 
     {
       // In case network failure during reading the body
-      Azure::Core::ETag eTag = downloadResponse->ETag;
+      const Azure::Core::ETag eTag = downloadResponse->Details.ETag;
 
       auto retryFunction
           = [this, options, eTag](
@@ -210,13 +210,14 @@ namespace Azure { namespace Storage { namespace Blobs {
           std::move(downloadResponse->BodyStream), reliableStreamOptions, retryFunction);
     }
     if (downloadResponse->BlobType == Models::BlobType::AppendBlob
-        && !downloadResponse->IsSealed.HasValue())
+        && !downloadResponse->Details.IsSealed.HasValue())
     {
-      downloadResponse->IsSealed = false;
+      downloadResponse->Details.IsSealed = false;
     }
-    if (downloadResponse->VersionId.HasValue() && !downloadResponse->IsCurrentVersion.HasValue())
+    if (downloadResponse->Details.VersionId.HasValue()
+        && !downloadResponse->Details.IsCurrentVersion.HasValue())
     {
-      downloadResponse->IsCurrentVersion = false;
+      downloadResponse->Details.IsCurrentVersion = false;
     }
     return downloadResponse;
   }
@@ -245,6 +246,7 @@ namespace Azure { namespace Storage { namespace Blobs {
     }
 
     auto firstChunk = Download(firstChunkOptions);
+    const Azure::Core::ETag eTag = firstChunk->Details.ETag;
 
     const int64_t blobSize = firstChunk->BlobSize;
     int64_t blobRangeSize;
@@ -278,40 +280,11 @@ namespace Azure { namespace Storage { namespace Blobs {
 
     auto returnTypeConverter = [](Azure::Core::Response<Models::DownloadBlobResult>& response) {
       Models::DownloadBlobToResult ret;
-      // Do not move ETag, we're gonna use it later
-      ret.ETag = response->ETag;
-      ret.LastModified = std::move(response->LastModified);
-      ret.CreatedOn = std::move(response->CreatedOn);
-      ret.ExpiresOn = std::move(response->ExpiresOn);
-      ret.LastAccessedOn = std::move(response->LastAccessedOn);
-      ret.HttpHeaders = std::move(response->HttpHeaders);
-      ret.Metadata = std::move(response->Metadata);
-      ret.SequenceNumber = std::move(response->SequenceNumber);
-      ret.CommittedBlockCount = std::move(response->CommittedBlockCount);
-      ret.IsSealed = std::move(response->IsSealed);
       ret.BlobType = std::move(response->BlobType);
-      ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
-      ret.LeaseDuration = std::move(response->LeaseDuration);
-      ret.LeaseState = std::move(response->LeaseState);
-      ret.LeaseStatus = std::move(response->LeaseStatus);
-      ret.IsServerEncrypted = response->IsServerEncrypted;
-      ret.EncryptionKeySha256 = std::move(response->EncryptionKeySha256);
-      ret.EncryptionScope = std::move(response->EncryptionScope);
-      ret.ObjectReplicationDestinationPolicyId
-          = std::move(response->ObjectReplicationDestinationPolicyId);
-      ret.ObjectReplicationSourceProperties
-          = std::move(response->ObjectReplicationSourceProperties);
-      ret.TagCount = std::move(response->TagCount);
-      ret.CopyId = std::move(response->CopyId);
-      ret.CopySource = std::move(response->CopySource);
-      ret.CopyStatus = std::move(response->CopyStatus);
-      ret.CopyStatusDescription = std::move(response->CopyStatusDescription);
-      ret.CopyProgress = std::move(response->CopyProgress);
-      ret.CopyCompletedOn = std::move(response->CopyCompletedOn);
-      ret.VersionId = std::move(response->VersionId);
-      ret.IsCurrentVersion = std::move(response->IsCurrentVersion);
-      ret.BlobSize = response->BlobSize;
       ret.ContentRange = std::move(response->ContentRange);
+      ret.BlobSize = response->BlobSize;
+      ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
+      ret.Details = std::move(response->Details);
       return Azure::Core::Response<Models::DownloadBlobToResult>(
           std::move(ret), response.ExtractRawResponse());
     };
@@ -327,7 +300,7 @@ namespace Azure { namespace Storage { namespace Blobs {
             chunkOptions.Range.GetValue().Length = length;
             if (!chunkOptions.AccessConditions.IfMatch.HasValue())
             {
-              chunkOptions.AccessConditions.IfMatch = firstChunk->ETag;
+              chunkOptions.AccessConditions.IfMatch = eTag;
             }
             auto chunk = Download(chunkOptions);
             int64_t bytesRead = Azure::Core::Http::BodyStream::ReadToCount(
@@ -343,6 +316,7 @@ namespace Azure { namespace Storage { namespace Blobs {
             if (chunkId == numChunks - 1)
             {
               ret = returnTypeConverter(chunk);
+              ret->TransactionalContentHash.Reset();
             }
           };
 
@@ -385,6 +359,7 @@ namespace Azure { namespace Storage { namespace Blobs {
     Storage::Details::FileWriter fileWriter(fileName);
 
     auto firstChunk = Download(firstChunkOptions);
+    const Azure::Core::ETag eTag = firstChunk->Details.ETag;
 
     const int64_t blobSize = firstChunk->BlobSize;
     int64_t blobRangeSize;
@@ -430,40 +405,11 @@ namespace Azure { namespace Storage { namespace Blobs {
 
     auto returnTypeConverter = [](Azure::Core::Response<Models::DownloadBlobResult>& response) {
       Models::DownloadBlobToResult ret;
-      // Do not move ETag, we're gonna use it later
-      ret.ETag = response->ETag;
-      ret.LastModified = std::move(response->LastModified);
-      ret.CreatedOn = std::move(response->CreatedOn);
-      ret.ExpiresOn = std::move(response->ExpiresOn);
-      ret.LastAccessedOn = std::move(response->LastAccessedOn);
-      ret.HttpHeaders = std::move(response->HttpHeaders);
-      ret.Metadata = std::move(response->Metadata);
-      ret.SequenceNumber = std::move(response->SequenceNumber);
-      ret.CommittedBlockCount = std::move(response->CommittedBlockCount);
-      ret.IsSealed = std::move(response->IsSealed);
       ret.BlobType = std::move(response->BlobType);
-      ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
-      ret.LeaseDuration = std::move(response->LeaseDuration);
-      ret.LeaseState = std::move(response->LeaseState);
-      ret.LeaseStatus = std::move(response->LeaseStatus);
-      ret.IsServerEncrypted = response->IsServerEncrypted;
-      ret.EncryptionKeySha256 = std::move(response->EncryptionKeySha256);
-      ret.EncryptionScope = std::move(response->EncryptionScope);
-      ret.ObjectReplicationDestinationPolicyId
-          = std::move(response->ObjectReplicationDestinationPolicyId);
-      ret.ObjectReplicationSourceProperties
-          = std::move(response->ObjectReplicationSourceProperties);
-      ret.TagCount = std::move(response->TagCount);
-      ret.CopyId = std::move(response->CopyId);
-      ret.CopySource = std::move(response->CopySource);
-      ret.CopyStatus = std::move(response->CopyStatus);
-      ret.CopyStatusDescription = std::move(response->CopyStatusDescription);
-      ret.CopyProgress = std::move(response->CopyProgress);
-      ret.CopyCompletedOn = std::move(response->CopyCompletedOn);
-      ret.VersionId = std::move(response->VersionId);
-      ret.IsCurrentVersion = std::move(response->IsCurrentVersion);
-      ret.BlobSize = response->BlobSize;
       ret.ContentRange = std::move(response->ContentRange);
+      ret.BlobSize = response->BlobSize;
+      ret.TransactionalContentHash = std::move(response->TransactionalContentHash);
+      ret.Details = std::move(response->Details);
       return Azure::Core::Response<Models::DownloadBlobToResult>(
           std::move(ret), response.ExtractRawResponse());
     };
@@ -479,7 +425,7 @@ namespace Azure { namespace Storage { namespace Blobs {
             chunkOptions.Range.GetValue().Length = length;
             if (!chunkOptions.AccessConditions.IfMatch.HasValue())
             {
-              chunkOptions.AccessConditions.IfMatch = firstChunk->ETag;
+              chunkOptions.AccessConditions.IfMatch = eTag;
             }
             auto chunk = Download(chunkOptions);
             bodyStreamToFile(
@@ -492,6 +438,7 @@ namespace Azure { namespace Storage { namespace Blobs {
             if (chunkId == numChunks - 1)
             {
               ret = returnTypeConverter(chunk);
+              ret->TransactionalContentHash.Reset();
             }
           };
 
diff --git a/sdk/storage/azure-storage-blobs/test/append_blob_client_test.cpp b/sdk/storage/azure-storage-blobs/test/append_blob_client_test.cpp
index e34dca836..896ef2ddc 100644
--- a/sdk/storage/azure-storage-blobs/test/append_blob_client_test.cpp
+++ b/sdk/storage/azure-storage-blobs/test/append_blob_client_test.cpp
@@ -274,8 +274,8 @@ namespace Azure { namespace Storage { namespace Test {
     blobClient.AppendBlock(&blockContent);
 
     auto downloadResult = blobClient.Download();
-    EXPECT_TRUE(downloadResult->IsSealed.HasValue());
-    EXPECT_FALSE(downloadResult->IsSealed.GetValue());
+    EXPECT_TRUE(downloadResult->Details.IsSealed.HasValue());
+    EXPECT_FALSE(downloadResult->Details.IsSealed.GetValue());
 
     auto getPropertiesResult = blobClient.GetProperties();
     EXPECT_TRUE(getPropertiesResult->IsSealed.HasValue());
@@ -309,8 +309,8 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_TRUE(sealResult->IsSealed);
 
     downloadResult = blobClient.Download();
-    EXPECT_TRUE(downloadResult->IsSealed.HasValue());
-    EXPECT_TRUE(downloadResult->IsSealed.GetValue());
+    EXPECT_TRUE(downloadResult->Details.IsSealed.HasValue());
+    EXPECT_TRUE(downloadResult->Details.IsSealed.GetValue());
 
     getPropertiesResult = blobClient.GetProperties();
     EXPECT_TRUE(getPropertiesResult->IsSealed.HasValue());
diff --git a/sdk/storage/azure-storage-blobs/test/blob_container_client_test.cpp b/sdk/storage/azure-storage-blobs/test/blob_container_client_test.cpp
index e118881ea..09f95925a 100644
--- a/sdk/storage/azure-storage-blobs/test/blob_container_client_test.cpp
+++ b/sdk/storage/azure-storage-blobs/test/blob_container_client_test.cpp
@@ -734,7 +734,7 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_FALSE(properties.TagCount.HasValue());
 
     auto downloadRet = blobClient.Download();
-    EXPECT_FALSE(downloadRet->TagCount.HasValue());
+    EXPECT_FALSE(downloadRet->Details.TagCount.HasValue());
 
     std::map<std::string, std::string> tags;
     std::string c1 = "k" + RandomString();
@@ -758,8 +758,8 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_EQ(properties.TagCount.GetValue(), static_cast<int64_t>(tags.size()));
 
     downloadRet = blobClient.Download();
-    EXPECT_TRUE(downloadRet->TagCount.HasValue());
-    EXPECT_EQ(downloadRet->TagCount.GetValue(), static_cast<int64_t>(tags.size()));
+    EXPECT_TRUE(downloadRet->Details.TagCount.HasValue());
+    EXPECT_EQ(downloadRet->Details.TagCount.GetValue(), static_cast<int64_t>(tags.size()));
 
     auto blobServiceClient = Azure::Storage::Blobs::BlobServiceClient::CreateFromConnectionString(
         StandardStorageConnectionString());
diff --git a/sdk/storage/azure-storage-blobs/test/block_blob_client_test.cpp b/sdk/storage/azure-storage-blobs/test/block_blob_client_test.cpp
index c80931c84..83c0cd4e0 100644
--- a/sdk/storage/azure-storage-blobs/test/block_blob_client_test.cpp
+++ b/sdk/storage/azure-storage-blobs/test/block_blob_client_test.cpp
@@ -88,11 +88,11 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
-    EXPECT_TRUE(res->ETag.HasValue());
-    EXPECT_TRUE(IsValidTime(res->LastModified));
-    EXPECT_TRUE(IsValidTime(res->CreatedOn));
-    EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-    EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+    EXPECT_TRUE(res->Details.ETag.HasValue());
+    EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+    EXPECT_TRUE(IsValidTime(res->Details.CreatedOn));
+    EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+    EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
     EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
     Azure::Storage::Blobs::DownloadBlobOptions options;
     options.Range = {1_MB, 2_MB};
@@ -137,8 +137,8 @@ namespace Azure { namespace Storage { namespace Test {
   {
     {
       auto res = m_blockBlobClient->Download();
-      ASSERT_TRUE(res->LastAccessedOn.HasValue());
-      EXPECT_TRUE(IsValidTime(res->LastAccessedOn.GetValue()));
+      ASSERT_TRUE(res->Details.LastAccessedOn.HasValue());
+      EXPECT_TRUE(IsValidTime(res->Details.LastAccessedOn.GetValue()));
     }
     {
       auto res = m_blockBlobClient->GetProperties();
@@ -184,10 +184,10 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
-    EXPECT_TRUE(res->ETag.HasValue());
-    EXPECT_TRUE(IsValidTime(res->LastModified));
-    EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-    EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+    EXPECT_TRUE(res->Details.ETag.HasValue());
+    EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+    EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+    EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
     EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
 
     Azure::Storage::Blobs::DownloadBlobOptions options;
@@ -230,16 +230,18 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_FALSE(properties.IncrementalCopyDestinationSnapshot.HasValue());
 
     auto downloadResult = blobClient.Download();
-    EXPECT_EQ(downloadResult->CopyId.GetValue(), res->CopyId);
-    EXPECT_FALSE(downloadResult->CopySource.GetValue().empty());
+    EXPECT_EQ(downloadResult->Details.CopyId.GetValue(), res->CopyId);
+    EXPECT_FALSE(downloadResult->Details.CopySource.GetValue().empty());
     EXPECT_TRUE(
-        downloadResult->CopyStatus.GetValue() == Azure::Storage::Blobs::Models::CopyStatus::Pending
-        || downloadResult->CopyStatus.GetValue()
+        downloadResult->Details.CopyStatus.GetValue()
+            == Azure::Storage::Blobs::Models::CopyStatus::Pending
+        || downloadResult->Details.CopyStatus.GetValue()
             == Azure::Storage::Blobs::Models::CopyStatus::Success);
-    EXPECT_FALSE(downloadResult->CopyProgress.GetValue().empty());
-    if (downloadResult->CopyStatus.GetValue() == Azure::Storage::Blobs::Models::CopyStatus::Success)
+    EXPECT_FALSE(downloadResult->Details.CopyProgress.GetValue().empty());
+    if (downloadResult->Details.CopyStatus.GetValue()
+        == Azure::Storage::Blobs::Models::CopyStatus::Success)
     {
-      EXPECT_TRUE(IsValidTime(downloadResult->CopyCompletedOn.GetValue()));
+      EXPECT_TRUE(IsValidTime(downloadResult->Details.CopyCompletedOn.GetValue()));
     }
   }
 
@@ -302,9 +304,9 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_TRUE(properties.IsCurrentVersion.GetValue());
 
     auto downloadResponse = blobClient.Download();
-    ASSERT_TRUE(downloadResponse->VersionId.HasValue());
-    ASSERT_TRUE(downloadResponse->IsCurrentVersion.HasValue());
-    EXPECT_TRUE(downloadResponse->IsCurrentVersion.GetValue());
+    ASSERT_TRUE(downloadResponse->Details.VersionId.HasValue());
+    ASSERT_TRUE(downloadResponse->Details.IsCurrentVersion.HasValue());
+    EXPECT_TRUE(downloadResponse->Details.IsCurrentVersion.GetValue());
 
     std::string version1 = properties.VersionId.GetValue();
 
@@ -324,10 +326,10 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_FALSE(properties.IsCurrentVersion.GetValue());
     EXPECT_EQ(version1, properties.VersionId.GetValue());
     downloadResponse = versionClient.Download();
-    ASSERT_TRUE(downloadResponse->VersionId.HasValue());
-    ASSERT_TRUE(downloadResponse->IsCurrentVersion.HasValue());
-    EXPECT_FALSE(downloadResponse->IsCurrentVersion.GetValue());
-    EXPECT_EQ(version1, downloadResponse->VersionId.GetValue());
+    ASSERT_TRUE(downloadResponse->Details.VersionId.HasValue());
+    ASSERT_TRUE(downloadResponse->Details.IsCurrentVersion.HasValue());
+    EXPECT_FALSE(downloadResponse->Details.IsCurrentVersion.GetValue());
+    EXPECT_EQ(version1, downloadResponse->Details.VersionId.GetValue());
 
     Azure::Storage::Blobs::ListBlobsSinglePageOptions options;
     options.Prefix = blobName;
@@ -723,18 +725,18 @@ namespace Azure { namespace Storage { namespace Test {
     auto res = blockBlobClient.DownloadTo(emptyContent.data(), 0);
     EXPECT_EQ(res->BlobSize, 0);
     EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
-    EXPECT_TRUE(res->ETag.HasValue());
-    EXPECT_TRUE(IsValidTime(res->LastModified));
-    EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-    EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+    EXPECT_TRUE(res->Details.ETag.HasValue());
+    EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+    EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+    EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
     EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
     res = blockBlobClient.DownloadTo(tempFilename);
     EXPECT_EQ(res->BlobSize, 0);
     EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
-    EXPECT_TRUE(res->ETag.HasValue());
-    EXPECT_TRUE(IsValidTime(res->LastModified));
-    EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-    EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+    EXPECT_TRUE(res->Details.ETag.HasValue());
+    EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+    EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+    EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
     EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
     EXPECT_TRUE(ReadFile(tempFilename).empty());
     DeleteFile(tempFilename);
@@ -742,18 +744,18 @@ namespace Azure { namespace Storage { namespace Test {
     res = blockBlobClient.DownloadTo(emptyContent.data(), static_cast<std::size_t>(8_MB));
     EXPECT_EQ(res->BlobSize, 0);
     EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
-    EXPECT_TRUE(res->ETag.HasValue());
-    EXPECT_TRUE(IsValidTime(res->LastModified));
-    EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-    EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+    EXPECT_TRUE(res->Details.ETag.HasValue());
+    EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+    EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+    EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
     EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
     res = blockBlobClient.DownloadTo(tempFilename);
     EXPECT_EQ(res->BlobSize, 0);
     EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
-    EXPECT_TRUE(res->ETag.HasValue());
-    EXPECT_TRUE(IsValidTime(res->LastModified));
-    EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-    EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+    EXPECT_TRUE(res->Details.ETag.HasValue());
+    EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+    EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+    EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
     EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
     EXPECT_TRUE(ReadFile(tempFilename).empty());
     DeleteFile(tempFilename);
@@ -769,18 +771,18 @@ namespace Azure { namespace Storage { namespace Test {
           emptyContent.data(), static_cast<std::size_t>(8_MB), options);
       EXPECT_EQ(res->BlobSize, 0);
       EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
-      EXPECT_TRUE(res->ETag.HasValue());
-      EXPECT_TRUE(IsValidTime(res->LastModified));
-      EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-      EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+      EXPECT_TRUE(res->Details.ETag.HasValue());
+      EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+      EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+      EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
       EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
       res = blockBlobClient.DownloadTo(tempFilename, options);
       EXPECT_EQ(res->BlobSize, 0);
       EXPECT_EQ(res->ContentRange.Length.GetValue(), 0);
-      EXPECT_TRUE(res->ETag.HasValue());
-      EXPECT_TRUE(IsValidTime(res->LastModified));
-      EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
-      EXPECT_EQ(res->Metadata, m_blobUploadOptions.Metadata);
+      EXPECT_TRUE(res->Details.ETag.HasValue());
+      EXPECT_TRUE(IsValidTime(res->Details.LastModified));
+      EXPECT_EQ(res->Details.HttpHeaders, m_blobUploadOptions.HttpHeaders);
+      EXPECT_EQ(res->Details.Metadata, m_blobUploadOptions.Metadata);
       EXPECT_EQ(res->BlobType, Azure::Storage::Blobs::Models::BlobType::BlockBlob);
       EXPECT_TRUE(ReadFile(tempFilename).empty());
       DeleteFile(tempFilename);
diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
index 6eeb4a3f7..c0dc16387 100644
--- a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
+++ b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
@@ -294,34 +294,34 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     auto result = m_blobClient.Download(blobOptions);
     Models::DownloadDataLakeFileResult ret;
     ret.Body = std::move(result->BodyStream);
-    ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->HttpHeaders));
+    ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->Details.HttpHeaders));
     ret.ContentRange = std::move(result->ContentRange);
     ret.FileSize = result->BlobSize;
     ret.TransactionalContentHash = std::move(result->TransactionalContentHash);
-    ret.ETag = std::move(result->ETag);
-    ret.LastModified = std::move(result->LastModified);
-    if (result->LeaseDuration.HasValue())
+    ret.ETag = std::move(result->Details.ETag);
+    ret.LastModified = std::move(result->Details.LastModified);
+    if (result->Details.LeaseDuration.HasValue())
     {
-      ret.LeaseDuration = Models::LeaseDurationType(result->LeaseDuration.GetValue().Get());
+      ret.LeaseDuration = Models::LeaseDurationType(result->Details.LeaseDuration.GetValue().Get());
     }
-    ret.LeaseState = result->LeaseState.HasValue()
-        ? FromBlobLeaseState(result->LeaseState.GetValue())
+    ret.LeaseState = result->Details.LeaseState.HasValue()
+        ? FromBlobLeaseState(result->Details.LeaseState.GetValue())
         : ret.LeaseState;
-    ret.LeaseStatus = result->LeaseStatus.HasValue()
-        ? FromBlobLeaseStatus(result->LeaseStatus.GetValue())
+    ret.LeaseStatus = result->Details.LeaseStatus.HasValue()
+        ? FromBlobLeaseStatus(result->Details.LeaseStatus.GetValue())
         : ret.LeaseStatus;
-    ret.Metadata = std::move(result->Metadata);
-    ret.CreatedOn = std::move(result->CreatedOn);
-    ret.ExpiresOn = std::move(result->ExpiresOn);
-    ret.LastAccessedOn = std::move(result->LastAccessedOn);
-    ret.CopyId = std::move(result->CopyId);
-    ret.CopySource = std::move(result->CopySource);
-    ret.CopyStatus = std::move(result->CopyStatus);
-    ret.CopyStatusDescription = std::move(result->CopyStatusDescription);
-    ret.CopyProgress = std::move(result->CopyProgress);
-    ret.CopyCompletedOn = std::move(result->CopyCompletedOn);
-    ret.VersionId = std::move(result->VersionId);
-    ret.IsCurrentVersion = std::move(result->IsCurrentVersion);
+    ret.Metadata = std::move(result->Details.Metadata);
+    ret.CreatedOn = std::move(result->Details.CreatedOn);
+    ret.ExpiresOn = std::move(result->Details.ExpiresOn);
+    ret.LastAccessedOn = std::move(result->Details.LastAccessedOn);
+    ret.CopyId = std::move(result->Details.CopyId);
+    ret.CopySource = std::move(result->Details.CopySource);
+    ret.CopyStatus = std::move(result->Details.CopyStatus);
+    ret.CopyStatusDescription = std::move(result->Details.CopyStatusDescription);
+    ret.CopyProgress = std::move(result->Details.CopyProgress);
+    ret.CopyCompletedOn = std::move(result->Details.CopyCompletedOn);
+    ret.VersionId = std::move(result->Details.VersionId);
+    ret.IsCurrentVersion = std::move(result->Details.IsCurrentVersion);
     ret.RequestId = std::move(result->RequestId);
     return Azure::Core::Response<Models::DownloadDataLakeFileResult>(
         std::move(ret), result.ExtractRawResponse());
@@ -365,13 +365,13 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
   {
     auto result = m_blockBlobClient.DownloadTo(buffer, bufferSize, options);
     Models::DownloadDataLakeFileToResult ret;
-    ret.ETag = std::move(result->ETag);
-    ret.LastModified = std::move(result->LastModified);
+    ret.ETag = std::move(result->Details.ETag);
+    ret.LastModified = std::move(result->Details.LastModified);
     ret.ContentLength = result->ContentRange.Length.GetValue();
-    ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->HttpHeaders));
-    ret.Metadata = std::move(result->Metadata);
-    ret.ServerEncrypted = result->IsServerEncrypted;
-    ret.EncryptionKeySha256 = std::move(result->EncryptionKeySha256);
+    ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->Details.HttpHeaders));
+    ret.Metadata = std::move(result->Details.Metadata);
+    ret.ServerEncrypted = result->Details.IsServerEncrypted;
+    ret.EncryptionKeySha256 = std::move(result->Details.EncryptionKeySha256);
     return Azure::Core::Response<Models::DownloadDataLakeFileToResult>(
         std::move(ret), result.ExtractRawResponse());
   }
@@ -382,13 +382,13 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
   {
     auto result = m_blockBlobClient.DownloadTo(fileName, options);
     Models::DownloadDataLakeFileToResult ret;
-    ret.ETag = std::move(result->ETag);
-    ret.LastModified = std::move(result->LastModified);
+    ret.ETag = std::move(result->Details.ETag);
+    ret.LastModified = std::move(result->Details.LastModified);
     ret.ContentLength = result->ContentRange.Length.GetValue();
-    ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->HttpHeaders));
-    ret.Metadata = std::move(result->Metadata);
-    ret.ServerEncrypted = result->IsServerEncrypted;
-    ret.EncryptionKeySha256 = std::move(result->EncryptionKeySha256);
+    ret.HttpHeaders = FromBlobHttpHeaders(std::move(result->Details.HttpHeaders));
+    ret.Metadata = std::move(result->Details.Metadata);
+    ret.ServerEncrypted = result->Details.IsServerEncrypted;
+    ret.EncryptionKeySha256 = std::move(result->Details.EncryptionKeySha256);
     return Azure::Core::Response<Models::DownloadDataLakeFileToResult>(
         std::move(ret), result.ExtractRawResponse());
   }