diff --git a/sdk/storage/inc/common/reliable_stream.hpp b/sdk/storage/inc/common/reliable_stream.hpp
index e8d24796a..dd14421d9 100644
--- a/sdk/storage/inc/common/reliable_stream.hpp
+++ b/sdk/storage/inc/common/reliable_stream.hpp
@@ -10,7 +10,7 @@
 namespace Azure { namespace Storage {
 
   // options used by the fm callback that will get a bodyStream starting from last offset
-  struct HTTPGetterInfo
+  struct HttpGetterInfo
   {
     int64_t Offset = 0;
   };
@@ -18,7 +18,7 @@ namespace Azure { namespace Storage {
   // Defines a fn signature to be use to get a bodyStream from an specific offset.
   typedef std::function<std::unique_ptr<Azure::Core::Http::BodyStream>(
       Azure::Core::Context const&,
-      HTTPGetterInfo const&)>
+      HttpGetterInfo const&)>
       HTTPGetter;
 
   // Options used by reliable stream
@@ -49,7 +49,7 @@ namespace Azure { namespace Storage {
     // callback to get a bodyStream in case Read operation fails
     HTTPGetter m_httpGetter;
     // Options to use when getting a new bodyStream like current offset
-    HTTPGetterInfo m_retryInfo;
+    HttpGetterInfo m_retryInfo;
 
   public:
     explicit ReliableStream(
diff --git a/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp b/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
index 95a263c5c..5781eb156 100644
--- a/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
+++ b/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
@@ -176,9 +176,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
   struct SetAccessControlRecursiveResponse
   {
-    int32_t DirectoriesSuccessful;
-    int32_t FilesSuccessful;
-    int32_t FailureCount;
+    int32_t DirectoriesSuccessful = int32_t();
+    int32_t FilesSuccessful = int32_t();
+    int32_t FailureCount = int32_t();
     std::vector<AclFailedEntry> FailedEntries;
 
     static SetAccessControlRecursiveResponse CreateFromJson(const nlohmann::json& node)
@@ -198,10 +198,10 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
   struct Path
   {
     std::string Name;
-    Azure::Core::Nullable<bool> IsDirectory;
+    bool IsDirectory = bool();
     std::string LastModified;
     std::string ETag;
-    Azure::Core::Nullable<int64_t> ContentLength;
+    int64_t ContentLength = int64_t();
     std::string Owner;
     std::string Group;
     std::string Permissions;
@@ -721,8 +721,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     std::string ResourceType;
     Azure::Core::Nullable<std::string> Properties;
     Azure::Core::Nullable<std::string> LeaseDuration;
-    LeaseStateType LeaseState;
-    LeaseStatusType LeaseStatus;
+    LeaseStateType LeaseState = LeaseStateType::Unknown;
+    LeaseStatusType LeaseStatus = LeaseStatusType::Unknown;
     Azure::Core::Nullable<std::string> ContentMD5;
   };
 
@@ -740,7 +740,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     Azure::Core::Nullable<std::string> Owner;
     Azure::Core::Nullable<std::string> Group;
     Azure::Core::Nullable<std::string> Permissions;
-    Azure::Core::Nullable<std::string> ACL;
+    Azure::Core::Nullable<std::string> Acl;
     Azure::Core::Nullable<std::string> LeaseDuration;
     Azure::Core::Nullable<LeaseStateType> LeaseState;
     Azure::Core::Nullable<LeaseStatusType> LeaseStatus;
@@ -825,7 +825,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<ServiceListFileSystemsResult> ListFileSystems(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const ListFileSystemsOptions& listFileSystemsOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
@@ -863,7 +863,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
     private:
       static Azure::Core::Response<ServiceListFileSystemsResult> ListFileSystemsParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -921,7 +921,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<FileSystemCreateResult> Create(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const CreateOptions& createOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
@@ -979,7 +979,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<FileSystemSetPropertiesResult> SetProperties(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const SetPropertiesOptions& setPropertiesOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@@ -1033,7 +1033,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<FileSystemGetPropertiesResult> GetProperties(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const GetPropertiesOptions& getPropertiesOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Head, url);
@@ -1077,7 +1077,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<FileSystemDeleteResult> Delete(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const DeleteOptions& deleteOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
@@ -1147,7 +1147,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<FileSystemListPathsResult> ListPaths(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const ListPathsOptions& listPathsOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
@@ -1192,7 +1192,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
     private:
       static Azure::Core::Response<FileSystemCreateResult> CreateParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1214,7 +1214,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<FileSystemSetPropertiesResult> SetPropertiesParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1235,7 +1235,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<FileSystemGetPropertiesResult> GetPropertiesParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1258,7 +1258,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<FileSystemDeleteResult> DeleteParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1277,7 +1277,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<FileSystemListPathsResult> ListPathsParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1412,7 +1412,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathCreateResult> Create(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const CreateOptions& createOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
@@ -1669,7 +1669,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           std::string url,
           Azure::Core::Http::BodyStream& bodyStream,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const UpdateOptions& updateOptions)
       {
         Azure::Core::Http::Request request(
@@ -1853,7 +1853,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathLeaseResult> Lease(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const LeaseOptions& leaseOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Post, url);
@@ -1957,7 +1957,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathReadResult> Read(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const ReadOptions& readOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url, true);
@@ -2052,7 +2052,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathGetPropertiesResult> GetProperties(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const GetPropertiesOptions& getPropertiesOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Head, url);
@@ -2146,7 +2146,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathDeleteResult> Delete(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const DeleteOptions& deleteOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
@@ -2243,7 +2243,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathSetAccessControlResult> SetAccessControl(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const SetAccessControlOptions& setAccessControlOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@@ -2344,7 +2344,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathSetAccessControlRecursiveResult> SetAccessControlRecursive(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const SetAccessControlRecursiveOptions& setAccessControlRecursiveOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@@ -2468,7 +2468,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       static Azure::Core::Response<PathFlushDataResult> FlushData(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const FlushDataOptions& flushDataOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url);
@@ -2600,7 +2600,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           std::string url,
           Azure::Core::Http::BodyStream& bodyStream,
           Azure::Core::Http::HttpPipeline& pipeline,
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           const AppendDataOptions& appendDataOptions)
       {
         Azure::Core::Http::Request request(
@@ -2645,7 +2645,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
     private:
       static Azure::Core::Response<PathCreateResult> CreateParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2683,7 +2683,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathUpdateResult> UpdateParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2769,7 +2769,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathLeaseResult> LeaseParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2816,7 +2816,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathReadResult> ReadParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2961,7 +2961,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathGetPropertiesResult> GetPropertiesParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3036,7 +3036,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           }
           if (response.GetHeaders().find(Details::c_HeaderXMsAcl) != response.GetHeaders().end())
           {
-            result.ACL = response.GetHeaders().at(Details::c_HeaderXMsAcl);
+            result.Acl = response.GetHeaders().at(Details::c_HeaderXMsAcl);
           }
           if (response.GetHeaders().find(Details::c_HeaderXMsLeaseDuration)
               != response.GetHeaders().end())
@@ -3066,7 +3066,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathDeleteResult> DeleteParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3089,7 +3089,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathSetAccessControlResult> SetAccessControlParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3111,7 +3111,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
       static Azure::Core::Response<PathSetAccessControlRecursiveResult>
       SetAccessControlRecursiveParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3141,7 +3141,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathFlushDataResult> FlushDataParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3168,7 +3168,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
       }
 
       static Azure::Core::Response<PathAppendDataResult> AppendDataParseResult(
-          Azure::Core::Context context,
+          const Azure::Core::Context& context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
diff --git a/sdk/storage/inc/shares/protocol/share_rest_client.hpp b/sdk/storage/inc/shares/protocol/share_rest_client.hpp
index afce62427..f35029492 100644
--- a/sdk/storage/inc/shares/protocol/share_rest_client.hpp
+++ b/sdk/storage/inc/shares/protocol/share_rest_client.hpp
@@ -989,7 +989,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
   {
   };
 
-  struct FileSetHTTPHeadersResult
+  struct FileSetHttpHeadersResult
   {
     std::string ETag;
     std::string LastModified;
@@ -1044,7 +1044,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
     bool IsServerEncrypted = bool();
   };
 
-  struct FileUploadRangeFromURLResult
+  struct FileUploadRangeFromUrlResult
   {
     std::string ETag;
     std::string LastModified;
@@ -2107,10 +2107,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           request.AddQueryParameter(
               Details::c_QueryTimeout, std::to_string(createOptions.Timeout.GetValue()));
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : createOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         if (createOptions.ShareQuota.HasValue())
         {
           request.AddHeader(
@@ -2229,10 +2239,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           request.AddQueryParameter(
               Details::c_QueryTimeout, std::to_string(createSnapshotOptions.Timeout.GetValue()));
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : createSnapshotOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         request.AddHeader(Details::c_HeaderVersion, createSnapshotOptions.ApiVersionParameter);
         return CreateSnapshotParseResult(context, pipeline.Send(context, request));
       }
@@ -2375,10 +2395,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           request.AddQueryParameter(
               Details::c_QueryTimeout, std::to_string(setMetadataOptions.Timeout.GetValue()));
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : setMetadataOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         request.AddHeader(Details::c_HeaderVersion, setMetadataOptions.ApiVersionParameter);
         return SetMetadataParseResult(context, pipeline.Send(context, request));
       }
@@ -3195,10 +3225,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           request.AddQueryParameter(
               Details::c_QueryTimeout, std::to_string(createOptions.Timeout.GetValue()));
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : createOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         request.AddHeader(Details::c_HeaderVersion, createOptions.ApiVersionParameter);
         if (createOptions.FilePermission.HasValue())
         {
@@ -3370,10 +3410,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           request.AddQueryParameter(
               Details::c_QueryTimeout, std::to_string(setMetadataOptions.Timeout.GetValue()));
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : setMetadataOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         request.AddHeader(Details::c_HeaderVersion, setMetadataOptions.ApiVersionParameter);
         return SetMetadataParseResult(context, pipeline.Send(context, request));
       }
@@ -4454,10 +4504,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
               Details::c_HeaderFileContentDisposition,
               createOptions.FileContentDisposition.GetValue());
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : createOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         if (createOptions.FilePermission.HasValue())
         {
           request.AddHeader(
@@ -4605,7 +4665,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
         return DeleteParseResult(context, pipeline.Send(context, request));
       }
 
-      struct SetHTTPHeadersOptions
+      struct SetHttpHeadersOptions
       {
         Azure::Core::Nullable<int32_t>
             Timeout; // The timeout parameter is expressed in seconds. For more information, see <a
@@ -4653,82 +4713,82 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
                              // active and matches this ID.
       };
 
-      static Azure::Core::Response<FileSetHTTPHeadersResult> SetHTTPHeaders(
+      static Azure::Core::Response<FileSetHttpHeadersResult> SetHttpHeaders(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
           Azure::Core::Context context,
-          const SetHTTPHeadersOptions& setHTTPHeadersOptions)
+          const SetHttpHeadersOptions& setHttpHeadersOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader(Details::c_HeaderContentLength, "0");
         request.AddQueryParameter(Details::c_QueryComp, "properties");
-        if (setHTTPHeadersOptions.Timeout.HasValue())
+        if (setHttpHeadersOptions.Timeout.HasValue())
         {
           request.AddQueryParameter(
-              Details::c_QueryTimeout, std::to_string(setHTTPHeadersOptions.Timeout.GetValue()));
+              Details::c_QueryTimeout, std::to_string(setHttpHeadersOptions.Timeout.GetValue()));
         }
-        request.AddHeader(Details::c_HeaderVersion, setHTTPHeadersOptions.ApiVersionParameter);
-        if (setHTTPHeadersOptions.XMsContentLength.HasValue())
+        request.AddHeader(Details::c_HeaderVersion, setHttpHeadersOptions.ApiVersionParameter);
+        if (setHttpHeadersOptions.XMsContentLength.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderFileContentLength,
-              std::to_string(setHTTPHeadersOptions.XMsContentLength.GetValue()));
+              std::to_string(setHttpHeadersOptions.XMsContentLength.GetValue()));
         }
-        if (setHTTPHeadersOptions.FileContentType.HasValue())
+        if (setHttpHeadersOptions.FileContentType.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderFileContentType, setHTTPHeadersOptions.FileContentType.GetValue());
+              Details::c_HeaderFileContentType, setHttpHeadersOptions.FileContentType.GetValue());
         }
-        if (setHTTPHeadersOptions.FileContentEncoding.HasValue())
+        if (setHttpHeadersOptions.FileContentEncoding.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderFileContentEncoding,
-              setHTTPHeadersOptions.FileContentEncoding.GetValue());
+              setHttpHeadersOptions.FileContentEncoding.GetValue());
         }
-        if (setHTTPHeadersOptions.FileContentLanguage.HasValue())
+        if (setHttpHeadersOptions.FileContentLanguage.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderFileContentLanguage,
-              setHTTPHeadersOptions.FileContentLanguage.GetValue());
+              setHttpHeadersOptions.FileContentLanguage.GetValue());
         }
-        if (setHTTPHeadersOptions.FileCacheControl.HasValue())
+        if (setHttpHeadersOptions.FileCacheControl.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderFileCacheControl, setHTTPHeadersOptions.FileCacheControl.GetValue());
+              Details::c_HeaderFileCacheControl, setHttpHeadersOptions.FileCacheControl.GetValue());
         }
-        if (setHTTPHeadersOptions.FileContentMD5.HasValue())
+        if (setHttpHeadersOptions.FileContentMD5.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderFileContentMD5, setHTTPHeadersOptions.FileContentMD5.GetValue());
+              Details::c_HeaderFileContentMD5, setHttpHeadersOptions.FileContentMD5.GetValue());
         }
-        if (setHTTPHeadersOptions.FileContentDisposition.HasValue())
+        if (setHttpHeadersOptions.FileContentDisposition.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderFileContentDisposition,
-              setHTTPHeadersOptions.FileContentDisposition.GetValue());
+              setHttpHeadersOptions.FileContentDisposition.GetValue());
         }
-        if (setHTTPHeadersOptions.FilePermission.HasValue())
+        if (setHttpHeadersOptions.FilePermission.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderFilePermission, setHTTPHeadersOptions.FilePermission.GetValue());
+              Details::c_HeaderFilePermission, setHttpHeadersOptions.FilePermission.GetValue());
         }
-        if (setHTTPHeadersOptions.FilePermissionKey.HasValue())
+        if (setHttpHeadersOptions.FilePermissionKey.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderFilePermissionKey,
-              setHTTPHeadersOptions.FilePermissionKey.GetValue());
+              setHttpHeadersOptions.FilePermissionKey.GetValue());
         }
-        request.AddHeader(Details::c_HeaderFileAttributes, setHTTPHeadersOptions.FileAttributes);
+        request.AddHeader(Details::c_HeaderFileAttributes, setHttpHeadersOptions.FileAttributes);
         request.AddHeader(
-            Details::c_HeaderFileCreationTime, setHTTPHeadersOptions.FileCreationTime);
+            Details::c_HeaderFileCreationTime, setHttpHeadersOptions.FileCreationTime);
         request.AddHeader(
-            Details::c_HeaderFileLastWriteTime, setHTTPHeadersOptions.FileLastWriteTime);
-        if (setHTTPHeadersOptions.LeaseIdOptional.HasValue())
+            Details::c_HeaderFileLastWriteTime, setHttpHeadersOptions.FileLastWriteTime);
+        if (setHttpHeadersOptions.LeaseIdOptional.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderLeaseId, setHTTPHeadersOptions.LeaseIdOptional.GetValue());
+              Details::c_HeaderLeaseId, setHttpHeadersOptions.LeaseIdOptional.GetValue());
         }
-        return SetHTTPHeadersParseResult(context, pipeline.Send(context, request));
+        return SetHttpHeadersParseResult(context, pipeline.Send(context, request));
       }
 
       struct SetMetadataOptions
@@ -4761,10 +4821,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           request.AddQueryParameter(
               Details::c_QueryTimeout, std::to_string(setMetadataOptions.Timeout.GetValue()));
         }
+        std::set<std::string> metadataKeys;
         for (const auto& pair : setMetadataOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         request.AddHeader(Details::c_HeaderVersion, setMetadataOptions.ApiVersionParameter);
         if (setMetadataOptions.LeaseIdOptional.HasValue())
         {
@@ -5045,7 +5115,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
         return UploadRangeParseResult(context, pipeline.Send(context, request));
       }
 
-      struct UploadRangeFromURLOptions
+      struct UploadRangeFromUrlOptions
       {
         Azure::Core::Nullable<int32_t>
             Timeout; // The timeout parameter is expressed in seconds. For more information, see <a
@@ -5087,59 +5157,59 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
                              // active and matches this ID.
       };
 
-      static Azure::Core::Response<FileUploadRangeFromURLResult> UploadRangeFromURL(
+      static Azure::Core::Response<FileUploadRangeFromUrlResult> UploadRangeFromUrl(
           std::string url,
           Azure::Core::Http::HttpPipeline& pipeline,
           Azure::Core::Context context,
-          const UploadRangeFromURLOptions& uploadRangeFromURLOptions)
+          const UploadRangeFromUrlOptions& uploadRangeFromUrlOptions)
       {
         Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader(Details::c_HeaderContentLength, "0");
         request.AddQueryParameter(Details::c_QueryComp, "range");
-        if (uploadRangeFromURLOptions.Timeout.HasValue())
+        if (uploadRangeFromUrlOptions.Timeout.HasValue())
         {
           request.AddQueryParameter(
               Details::c_QueryTimeout,
-              std::to_string(uploadRangeFromURLOptions.Timeout.GetValue()));
+              std::to_string(uploadRangeFromUrlOptions.Timeout.GetValue()));
         }
-        request.AddHeader(Details::c_HeaderRange, uploadRangeFromURLOptions.TargetRange);
-        request.AddHeader(Details::c_HeaderCopySource, uploadRangeFromURLOptions.CopySource);
-        if (uploadRangeFromURLOptions.SourceRange.HasValue())
+        request.AddHeader(Details::c_HeaderRange, uploadRangeFromUrlOptions.TargetRange);
+        request.AddHeader(Details::c_HeaderCopySource, uploadRangeFromUrlOptions.CopySource);
+        if (uploadRangeFromUrlOptions.SourceRange.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderSourceRange, uploadRangeFromURLOptions.SourceRange.GetValue());
+              Details::c_HeaderSourceRange, uploadRangeFromUrlOptions.SourceRange.GetValue());
         }
         request.AddHeader(
             Details::c_HeaderFileRangeWriteFromUrl,
-            FileRangeWriteFromUrlTypeToString(uploadRangeFromURLOptions.XMsWrite));
+            FileRangeWriteFromUrlTypeToString(uploadRangeFromUrlOptions.XMsWrite));
         request.AddHeader(
             Details::c_HeaderContentLength,
-            std::to_string(uploadRangeFromURLOptions.ContentLength));
-        if (uploadRangeFromURLOptions.SourceContentCrc64.HasValue())
+            std::to_string(uploadRangeFromUrlOptions.ContentLength));
+        if (uploadRangeFromUrlOptions.SourceContentCrc64.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderSourceContentCrc64,
-              uploadRangeFromURLOptions.SourceContentCrc64.GetValue());
+              uploadRangeFromUrlOptions.SourceContentCrc64.GetValue());
         }
-        if (uploadRangeFromURLOptions.SourceIfMatchCrc64.HasValue())
+        if (uploadRangeFromUrlOptions.SourceIfMatchCrc64.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderSourceIfMatchCrc64,
-              uploadRangeFromURLOptions.SourceIfMatchCrc64.GetValue());
+              uploadRangeFromUrlOptions.SourceIfMatchCrc64.GetValue());
         }
-        if (uploadRangeFromURLOptions.SourceIfNoneMatchCrc64.HasValue())
+        if (uploadRangeFromUrlOptions.SourceIfNoneMatchCrc64.HasValue())
         {
           request.AddHeader(
               Details::c_HeaderSourceIfNoneMatchCrc64,
-              uploadRangeFromURLOptions.SourceIfNoneMatchCrc64.GetValue());
+              uploadRangeFromUrlOptions.SourceIfNoneMatchCrc64.GetValue());
         }
-        request.AddHeader(Details::c_HeaderVersion, uploadRangeFromURLOptions.ApiVersionParameter);
-        if (uploadRangeFromURLOptions.LeaseIdOptional.HasValue())
+        request.AddHeader(Details::c_HeaderVersion, uploadRangeFromUrlOptions.ApiVersionParameter);
+        if (uploadRangeFromUrlOptions.LeaseIdOptional.HasValue())
         {
           request.AddHeader(
-              Details::c_HeaderLeaseId, uploadRangeFromURLOptions.LeaseIdOptional.GetValue());
+              Details::c_HeaderLeaseId, uploadRangeFromUrlOptions.LeaseIdOptional.GetValue());
         }
-        return UploadRangeFromURLParseResult(context, pipeline.Send(context, request));
+        return UploadRangeFromUrlParseResult(context, pipeline.Send(context, request));
       }
 
       struct GetRangeListOptions
@@ -5269,10 +5339,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
               Details::c_QueryTimeout, std::to_string(startCopyOptions.Timeout.GetValue()));
         }
         request.AddHeader(Details::c_HeaderVersion, startCopyOptions.ApiVersionParameter);
+        std::set<std::string> metadataKeys;
         for (const auto& pair : startCopyOptions.Metadata)
         {
+          std::string key = pair.first;
+          std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+            return static_cast<char>(std::tolower(c));
+          });
+          if (metadataKeys.insert(key).second == false)
+          {
+            throw std::runtime_error("duplicate keys in metadata");
+          }
           request.AddHeader(Details::c_HeaderMetadata + ("-" + pair.first), pair.second);
         }
+        metadataKeys.clear();
         request.AddHeader(Details::c_HeaderCopySource, startCopyOptions.CopySource);
         if (startCopyOptions.FilePermission.HasValue())
         {
@@ -5910,7 +5990,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
         }
       }
 
-      static Azure::Core::Response<FileSetHTTPHeadersResult> SetHTTPHeadersParseResult(
+      static Azure::Core::Response<FileSetHttpHeadersResult> SetHttpHeadersParseResult(
           Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
@@ -5918,7 +5998,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
         if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
         {
           // Success
-          FileSetHTTPHeadersResult result;
+          FileSetHttpHeadersResult result;
           result.ETag = response.GetHeaders().at(Details::c_HeaderETag);
           result.LastModified = response.GetHeaders().at(Details::c_HeaderLastModified);
           result.IsServerEncrypted
@@ -5930,7 +6010,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
           result.FileChangeTime = response.GetHeaders().at(Details::c_HeaderFileChangeTime);
           result.FileId = response.GetHeaders().at(Details::c_HeaderFileId);
           result.FileParentId = response.GetHeaders().at(Details::c_HeaderFileParentId);
-          return Azure::Core::Response<FileSetHTTPHeadersResult>(
+          return Azure::Core::Response<FileSetHttpHeadersResult>(
               std::move(result), std::move(responsePtr));
         }
         else
@@ -6080,7 +6160,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
         }
       }
 
-      static Azure::Core::Response<FileUploadRangeFromURLResult> UploadRangeFromURLParseResult(
+      static Azure::Core::Response<FileUploadRangeFromUrlResult> UploadRangeFromUrlParseResult(
           Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
@@ -6088,13 +6168,13 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
         if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
         {
           // Success (Created).
-          FileUploadRangeFromURLResult result;
+          FileUploadRangeFromUrlResult result;
           result.ETag = response.GetHeaders().at(Details::c_HeaderETag);
           result.LastModified = response.GetHeaders().at(Details::c_HeaderLastModified);
           result.XMsContentCrc64 = response.GetHeaders().at(Details::c_HeaderXMsContentCrc64);
           result.IsServerEncrypted
               = response.GetHeaders().at(Details::c_HeaderRequestIsServerEncrypted) == "true";
-          return Azure::Core::Response<FileUploadRangeFromURLResult>(
+          return Azure::Core::Response<FileUploadRangeFromUrlResult>(
               std::move(result), std::move(responsePtr));
         }
         else
diff --git a/sdk/storage/inc/shares/share_responses.hpp b/sdk/storage/inc/shares/share_responses.hpp
index b95847aa6..5c611fc76 100644
--- a/sdk/storage/inc/shares/share_responses.hpp
+++ b/sdk/storage/inc/shares/share_responses.hpp
@@ -89,12 +89,12 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
   using StartCopyFileResult = FileStartCopyResult;
   using AbortCopyFileResult = FileAbortCopyResult;
   using GetFilePropertiesResult = FileGetPropertiesResult;
-  using SetFilePropertiesResult = FileSetHTTPHeadersResult;
-  using ResizeFileResult = FileSetHTTPHeadersResult;
+  using SetFilePropertiesResult = FileSetHttpHeadersResult;
+  using ResizeFileResult = FileSetHttpHeadersResult;
   using SetFileMetadataResult = FileSetMetadataResult;
   using UploadFileRangeResult = FileUploadRangeResult;
   using ClearFileRangeResult = FileUploadRangeResult;
-  using UploadFileRangeFromUrlResult = FileUploadRangeFromURLResult;
+  using UploadFileRangeFromUrlResult = FileUploadRangeFromUrlResult;
   using GetFileRangeListResult = FileGetRangeListResult;
   using ListFileHandlesSegmentedResult = ListDirectoryHandlesSegmentedResult;
   using ForceCloseFileHandlesResult = FileForceCloseHandlesResult;
diff --git a/sdk/storage/src/blobs/blob_client.cpp b/sdk/storage/src/blobs/blob_client.cpp
index 9bb449724..a5004366c 100644
--- a/sdk/storage/src/blobs/blob_client.cpp
+++ b/sdk/storage/src/blobs/blob_client.cpp
@@ -191,7 +191,7 @@ namespace Azure { namespace Storage { namespace Blobs {
       auto retryFunction
           = [this, options, eTag](
                 const Azure::Core::Context& context,
-                const HTTPGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
+                const HttpGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
         unused(context);
 
         DownloadBlobOptions newOptions = options;
diff --git a/sdk/storage/src/datalake/datalake_path_client.cpp b/sdk/storage/src/datalake/datalake_path_client.cpp
index 2e985b2f3..4fc0b5acf 100644
--- a/sdk/storage/src/datalake/datalake_path_client.cpp
+++ b/sdk/storage/src/datalake/datalake_path_client.cpp
@@ -320,9 +320,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     auto result = DataLakeRestClient::Path::GetProperties(
         m_dfsUri.ToString(), *m_pipeline, options.Context, protocolLayerOptions);
     Azure::Core::Nullable<std::vector<Acl>> acl;
-    if (result->ACL.HasValue())
+    if (result->Acl.HasValue())
     {
-      acl = Acl::DeserializeAcls(result->ACL.GetValue());
+      acl = Acl::DeserializeAcls(result->Acl.GetValue());
     }
     auto ret = GetPathAccessControlResult{};
     ret.ETag = std::move(result->ETag);
diff --git a/sdk/storage/src/shares/share_file_client.cpp b/sdk/storage/src/shares/share_file_client.cpp
index 1058ad31b..e4307089e 100644
--- a/sdk/storage/src/shares/share_file_client.cpp
+++ b/sdk/storage/src/shares/share_file_client.cpp
@@ -238,7 +238,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       auto retryFunction
           = [this, options, eTag](
                 const Azure::Core::Context& context,
-                const HTTPGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
+                const HttpGetterInfo& retryInfo) -> std::unique_ptr<Azure::Core::Http::BodyStream> {
         unused(context);
 
         DownloadFileOptions newOptions = options;
@@ -322,7 +322,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       FileShareSmbProperties smbProperties,
       const SetFilePropertiesOptions& options) const
   {
-    auto protocolLayerOptions = ShareRestClient::File::SetHTTPHeadersOptions();
+    auto protocolLayerOptions = ShareRestClient::File::SetHttpHeadersOptions();
     protocolLayerOptions.FileAttributes = FileAttributesToString(smbProperties.Attributes);
     if (smbProperties.FileCreationTime.HasValue())
     {
@@ -376,7 +376,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       protocolLayerOptions.FileContentDisposition = httpHeaders.ContentDisposition;
     }
 
-    return ShareRestClient::File::SetHTTPHeaders(
+    return ShareRestClient::File::SetHttpHeaders(
         m_shareFileUri.ToString(), *m_pipeline, options.Context, protocolLayerOptions);
   }
 
@@ -413,7 +413,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
       int64_t length,
       const UploadFileRangeFromUrlOptions& options) const
   {
-    auto protocolLayerOptions = ShareRestClient::File::UploadRangeFromURLOptions();
+    auto protocolLayerOptions = ShareRestClient::File::UploadRangeFromUrlOptions();
     protocolLayerOptions.XMsWrite = FileRangeWriteFromUrlType::Update;
     protocolLayerOptions.CopySource = std::move(sourceUrl);
     protocolLayerOptions.ContentLength = length;
@@ -437,7 +437,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
     protocolLayerOptions.SourceIfMatchCrc64 = options.SourceIfMatchCrc64;
     protocolLayerOptions.SourceIfNoneMatchCrc64 = options.SourceIfNoneMatchCrc64;
     protocolLayerOptions.LeaseIdOptional = options.AccessConditions.LeaseId;
-    return ShareRestClient::File::UploadRangeFromURL(
+    return ShareRestClient::File::UploadRangeFromUrl(
         m_shareFileUri.ToString(), *m_pipeline, options.Context, protocolLayerOptions);
   }