Lesson 35 - Get Compute Auth Token Working

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ClientConfiguration.h

@@ -0,0 +1,69 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3ExpressIdentityProvider.h>
+#include <aws/core/client/GenericClientConfiguration.h>
+#include <aws/core/auth/signer/AWSAuthV4Signer.h>
+
+
+namespace Aws
+{
+    namespace S3
+    {
+        enum class US_EAST_1_REGIONAL_ENDPOINT_OPTION
+        {
+            NOT_SET,
+            LEGACY,   //stands for using global endpoint for us-east-1,
+            REGIONAL //stands for using regional endpoint for us-east-1
+        };
+
+        struct AWS_S3_API S3ClientConfiguration : public Aws::Client::GenericClientConfiguration
+        {
+            using BaseClientConfigClass = Aws::Client::GenericClientConfiguration;
+
+            S3ClientConfiguration(const Client::ClientConfigurationInitValues &configuration = {});
+
+            /**
+            * Create a configuration based on settings in the aws configuration file for the given profile name.
+            * The configuration file location can be set via the environment variable AWS_CONFIG_FILE
+            * @param profileName the aws profile name.
+            * @param shouldDisableIMDS whether or not to disable IMDS calls.
+            */
+            S3ClientConfiguration(const char* profileName, bool shouldDisableIMDS = false);
+
+            /**
+            * Create a configuration with a predefined smart defaults
+            * @param useSmartDefaults, required to differentiate c-tors
+            * @param defaultMode, default mode to use
+            * @param shouldDisableIMDS whether or not to disable IMDS calls.
+            */
+            S3ClientConfiguration(bool useSmartDefaults, const char* defaultMode = "legacy", bool shouldDisableIMDS = false);
+
+            /**
+            * Converting constructors for compatibility with a legacy code
+            */
+            S3ClientConfiguration(const Client::ClientConfiguration& config,
+                                  Client::AWSAuthV4Signer::PayloadSigningPolicy iPayloadSigningPolicy = Client::AWSAuthV4Signer::PayloadSigningPolicy::Never,
+                                  bool iUseVirtualAddressing = true,
+                                  US_EAST_1_REGIONAL_ENDPOINT_OPTION iUseUSEast1RegionalEndPointOption = US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET);
+
+            bool useVirtualAddressing = true;
+            US_EAST_1_REGIONAL_ENDPOINT_OPTION useUSEast1RegionalEndPointOption = US_EAST_1_REGIONAL_ENDPOINT_OPTION::NOT_SET;
+            bool disableMultiRegionAccessPoints = false;
+            bool useArnRegion = false;
+            Client::AWSAuthV4Signer::PayloadSigningPolicy payloadSigningPolicy = Client::AWSAuthV4Signer::PayloadSigningPolicy::RequestDependent;
+            bool disableS3ExpressAuth = false;
+            using IdentityProviderSupplier = std::function<std::shared_ptr<S3ExpressIdentityProvider> (const S3Client &)>;
+            IdentityProviderSupplier identityProviderSupplier = [](const S3Client &client) -> std::shared_ptr<S3ExpressIdentityProvider> {
+                return Aws::MakeShared<DefaultS3ExpressIdentityProvider>("S3ClientConfiguration", client);
+            };
+        private:
+            void LoadS3SpecificConfig(const Aws::String& profileName);
+        };
+    }
+}

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3EndpointProvider.h

@@ -0,0 +1,121 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3ClientConfiguration.h>
+#include <aws/core/endpoint/DefaultEndpointProvider.h>
+#include <aws/core/endpoint/EndpointParameter.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+
+#include <aws/s3/S3EndpointRules.h>
+
+
+namespace Aws
+{
+namespace S3
+{
+namespace Endpoint
+{
+using S3ClientConfiguration = Aws::S3::S3ClientConfiguration;
+using EndpointParameters = Aws::Endpoint::EndpointParameters;
+using Aws::Endpoint::EndpointProviderBase;
+using Aws::Endpoint::DefaultEndpointProvider;
+
+class AWS_S3_API S3ClientContextParameters : public Aws::Endpoint::ClientContextParameters
+{
+public:
+    virtual ~S3ClientContextParameters(){};
+
+    /**
+    * Forces this client to use path-style addressing for buckets.
+    */
+    void SetForcePathStyle(bool value);
+    const ClientContextParameters::EndpointParameter& GetForcePathStyle() const;
+
+    /**
+    * Disables this client's usage of Multi-Region Access Points.
+    */
+    void SetDisableMultiRegionAccessPoints(bool value);
+    const ClientContextParameters::EndpointParameter& GetDisableMultiRegionAccessPoints() const;
+
+    /**
+    * Enables this client to use an ARN's region when constructing an endpoint instead of the client's configured region.
+    */
+    void SetUseArnRegion(bool value);
+    const ClientContextParameters::EndpointParameter& GetUseArnRegion() const;
+
+    /**
+    * Enables this client to use S3 Transfer Acceleration endpoints.
+    */
+    void SetAccelerate(bool value);
+    const ClientContextParameters::EndpointParameter& GetAccelerate() const;
+
+    /**
+    * Disables this client's usage of Session Auth for S3Express
+      buckets and reverts to using conventional SigV4 for those.
+    */
+    void SetDisableS3ExpressSessionAuth(bool value);
+    const ClientContextParameters::EndpointParameter& GetDisableS3ExpressSessionAuth() const;
+};
+
+class AWS_S3_API S3BuiltInParameters : public Aws::Endpoint::BuiltInParameters
+{
+public:
+    virtual ~S3BuiltInParameters(){};
+    using Aws::Endpoint::BuiltInParameters::SetFromClientConfiguration;
+    virtual void SetFromClientConfiguration(const S3ClientConfiguration& config);
+};
+
+/**
+ * The type for the S3 Client Endpoint Provider.
+ * Inherit from this Base class / "Interface" should you want to provide a custom endpoint provider.
+ * The SDK must use service-specific type for each service per specification.
+ */
+using S3EndpointProviderBase =
+    EndpointProviderBase<S3ClientConfiguration, S3BuiltInParameters, S3ClientContextParameters>;
+
+using S3DefaultEpProviderBase =
+    DefaultEndpointProvider<S3ClientConfiguration, S3BuiltInParameters, S3ClientContextParameters>;
+
+} // namespace Endpoint
+} // namespace S3
+
+namespace Endpoint
+{
+/**
+ * Export endpoint provider symbols for Windows DLL, otherwise declare as extern
+ */
+AWS_S3_EXTERN template class AWS_S3_API
+    Aws::Endpoint::EndpointProviderBase<S3::Endpoint::S3ClientConfiguration, S3::Endpoint::S3BuiltInParameters, S3::Endpoint::S3ClientContextParameters>;
+
+AWS_S3_EXTERN template class AWS_S3_API
+    Aws::Endpoint::DefaultEndpointProvider<S3::Endpoint::S3ClientConfiguration, S3::Endpoint::S3BuiltInParameters, S3::Endpoint::S3ClientContextParameters>;
+} // namespace Endpoint
+
+namespace S3
+{
+namespace Endpoint
+{
+/**
+ * Default endpoint provider used for this service
+ */
+class AWS_S3_API S3EndpointProvider : public S3DefaultEpProviderBase
+{
+public:
+    using S3ResolveEndpointOutcome = Aws::Endpoint::ResolveEndpointOutcome;
+
+    S3EndpointProvider()
+      : S3DefaultEpProviderBase(Aws::S3::S3EndpointRules::GetRulesBlob(), Aws::S3::S3EndpointRules::RulesBlobSize)
+    {}
+
+    ~S3EndpointProvider()
+    {
+    }
+};
+} // namespace Endpoint
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3EndpointRules.h

@@ -0,0 +1,23 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <cstddef>
+#include <aws/s3/S3_EXPORTS.h>
+
+namespace Aws
+{
+namespace S3
+{
+class S3EndpointRules
+{
+public:
+    static const size_t RulesBlobStrLen;
+    static const size_t RulesBlobSize;
+
+    static const char* GetRulesBlob();
+};
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ErrorMarshaller.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+
+namespace Aws
+{
+namespace Client
+{
+
+class AWS_S3_API S3ErrorMarshaller : public Aws::Client::XmlErrorMarshaller
+{
+public:
+  Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
+  virtual Aws::String ExtractRegion(const AWSError<CoreErrors>&) const override;
+  virtual Aws::String ExtractEndpoint(const AWSError<CoreErrors>&) const override;
+  virtual AWSError<Aws::Client::CoreErrors>  Marshall(const Aws::Http::HttpResponse& response) const override;
+};
+
+} // namespace Client
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3Errors.h

@@ -0,0 +1,79 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/s3/S3_EXPORTS.h>
+
+namespace Aws
+{
+namespace S3
+{
+enum class S3Errors
+{
+  //From Core//
+  //////////////////////////////////////////////////////////////////////////////////////////
+  INCOMPLETE_SIGNATURE = 0,
+  INTERNAL_FAILURE = 1,
+  INVALID_ACTION = 2,
+  INVALID_CLIENT_TOKEN_ID = 3,
+  INVALID_PARAMETER_COMBINATION = 4,
+  INVALID_QUERY_PARAMETER = 5,
+  INVALID_PARAMETER_VALUE = 6,
+  MISSING_ACTION = 7, // SDK should never allow
+  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
+  MISSING_PARAMETER = 9, // SDK should never allow
+  OPT_IN_REQUIRED = 10,
+  REQUEST_EXPIRED = 11,
+  SERVICE_UNAVAILABLE = 12,
+  THROTTLING = 13,
+  VALIDATION = 14,
+  ACCESS_DENIED = 15,
+  RESOURCE_NOT_FOUND = 16,
+  UNRECOGNIZED_CLIENT = 17,
+  MALFORMED_QUERY_STRING = 18,
+  SLOW_DOWN = 19,
+  REQUEST_TIME_TOO_SKEWED = 20,
+  INVALID_SIGNATURE = 21,
+  SIGNATURE_DOES_NOT_MATCH = 22,
+  INVALID_ACCESS_KEY_ID = 23,
+  REQUEST_TIMEOUT = 24,
+  NETWORK_CONNECTION = 99,
+
+  UNKNOWN = 100,
+  ///////////////////////////////////////////////////////////////////////////////////////////
+
+  BUCKET_ALREADY_EXISTS= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
+  BUCKET_ALREADY_OWNED_BY_YOU,
+  INVALID_OBJECT_STATE,
+  NO_SUCH_BUCKET,
+  NO_SUCH_KEY,
+  NO_SUCH_UPLOAD,
+  OBJECT_ALREADY_IN_ACTIVE_TIER,
+  OBJECT_NOT_IN_ACTIVE_TIER
+};
+
+class AWS_S3_API S3Error : public Aws::Client::AWSError<S3Errors>
+{
+public:
+  S3Error() {}
+  S3Error(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<S3Errors>(rhs) {}
+  S3Error(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<S3Errors>(rhs) {}
+  S3Error(const Aws::Client::AWSError<S3Errors>& rhs) : Aws::Client::AWSError<S3Errors>(rhs) {}
+  S3Error(Aws::Client::AWSError<S3Errors>&& rhs) : Aws::Client::AWSError<S3Errors>(rhs) {}
+
+  template <typename T>
+  T GetModeledError();
+};
+
+namespace S3ErrorMapper
+{
+  AWS_S3_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
+}
+
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ExpressIdentity.h

@@ -0,0 +1,71 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <smithy/identity/identity/AwsCredentialIdentityBase.h>
+
+namespace Aws {
+    namespace S3 {
+        class S3ExpressIdentity final: public smithy::AwsCredentialIdentityBase {
+        public:
+            S3ExpressIdentity() = default;
+
+            inline S3ExpressIdentity(String accessKeyId,
+                String secretKeyId,
+                String sessionToken,
+                const Utils::DateTime &expiration) :
+                m_accessKeyId(std::move(accessKeyId)),
+                m_secretKeyId(std::move(secretKeyId)),
+                m_sessionToken(std::move(sessionToken)),
+                m_expiration(expiration) {}
+
+            const String &getAccessKeyId() const {
+                return m_accessKeyId;
+            }
+
+            const String &getSecretKeyId() const {
+                return m_secretKeyId;
+            }
+
+            const String &getSessionToken() const {
+                return m_sessionToken;
+            }
+
+            const Utils::DateTime &getExpiration() const {
+                return m_expiration;
+            }
+
+            String accessKeyId() const override
+            {
+                return getAccessKeyId();
+            }
+
+            String secretAccessKey() const override
+            {
+                return getSecretKeyId();
+            }
+
+            Crt::Optional<String> sessionToken() const override
+            {
+                return getSessionToken();
+            }
+
+            Crt::Optional<DateTime> expiration() const override
+            {
+                return getExpiration();
+            }
+
+
+        private:
+            Aws::String m_accessKeyId;
+            Aws::String m_secretKeyId;
+            Aws::String m_sessionToken;
+            Aws::Utils::DateTime m_expiration;
+        };
+    }
+}

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ExpressIdentityProvider.h

@@ -0,0 +1,100 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/utils/memory/stl/AWSSet.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/ConcurrentCache.h>
+#include <aws/core/auth/signer/AWSAuthSignerBase.h>
+#include <aws/s3/S3ExpressIdentity.h>
+#include <smithy/identity/resolver/AwsIdentityResolverBase.h>
+#include <thread>
+#include <condition_variable>
+
+namespace Aws {
+    namespace Http {
+        struct ServiceSpecificParameters;
+    }
+
+    namespace S3 {
+        class S3Client;
+        class S3ExpressIdentityProvider: public smithy::IdentityResolverBase<S3ExpressIdentity> {
+        public:
+            explicit S3ExpressIdentityProvider(const S3Client &s3Client) : m_s3Client(s3Client) {}
+
+            virtual S3ExpressIdentity
+            GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) = 0;
+
+            ResolveIdentityFutureOutcome
+            getIdentity(const IdentityProperties& identityProperties, const AdditionalParameters& additionalParameters) override;
+            S3ExpressIdentity
+            getIdentity(const Aws::String &bucketName);
+
+            virtual ~S3ExpressIdentityProvider() {}
+
+        protected:
+            std::shared_ptr<std::mutex> GetMutexForBucketName(const Aws::String& bucketName);
+
+        private:
+            const S3Client &m_s3Client;
+            mutable std::mutex m_bucketNameMapMutex;
+            Aws::Map<Aws::String, std::shared_ptr<std::mutex>> m_bucketNameMutex;
+        };
+
+        class DefaultS3ExpressIdentityProvider : public S3ExpressIdentityProvider {
+        public:
+            explicit DefaultS3ExpressIdentityProvider(const S3Client &m_s3Client);
+
+            DefaultS3ExpressIdentityProvider(const S3Client &s3Client,
+                std::shared_ptr<Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> credentialsCache);
+
+            DefaultS3ExpressIdentityProvider(const DefaultS3ExpressIdentityProvider& other) = delete;
+            DefaultS3ExpressIdentityProvider(DefaultS3ExpressIdentityProvider&& other) noexcept = delete;
+            DefaultS3ExpressIdentityProvider& operator=(const DefaultS3ExpressIdentityProvider& other) = delete;
+            DefaultS3ExpressIdentityProvider& operator=(DefaultS3ExpressIdentityProvider&& other) noexcept = delete;
+
+            virtual ~DefaultS3ExpressIdentityProvider() override = default;
+
+            S3ExpressIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;
+
+        private:
+            mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> m_credentialsCache;
+        };
+
+        class DefaultAsyncS3ExpressIdentityProvider : public S3ExpressIdentityProvider {
+        public:
+            explicit DefaultAsyncS3ExpressIdentityProvider(const S3Client &m_s3Client,
+                std::chrono::minutes refreshPeriod = std::chrono::minutes(1));
+
+            DefaultAsyncS3ExpressIdentityProvider(const S3Client &s3Client,
+                std::shared_ptr<Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> credentialsCache,
+                std::chrono::minutes refreshPeriod = std::chrono::minutes(1));
+
+            DefaultAsyncS3ExpressIdentityProvider(const DefaultAsyncS3ExpressIdentityProvider& other) = delete;
+            DefaultAsyncS3ExpressIdentityProvider(DefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
+            DefaultAsyncS3ExpressIdentityProvider& operator=(const DefaultAsyncS3ExpressIdentityProvider& other) = delete;
+            DefaultAsyncS3ExpressIdentityProvider& operator=(DefaultAsyncS3ExpressIdentityProvider&& other) noexcept = delete;
+
+            virtual ~DefaultAsyncS3ExpressIdentityProvider() override;
+
+            S3ExpressIdentity GetS3ExpressIdentity(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) override;
+
+        private:
+            void refreshIdentities(std::chrono::minutes refreshPeriod);
+            void threadSafeKeyInsert(const Aws::String& key);
+            bool threadSafeKeyHas(const Aws::String& key);
+            void threadSafeKeyEmpty();
+
+            mutable std::shared_ptr<Aws::Utils::ConcurrentCache<Aws::String, S3ExpressIdentity>> m_credentialsCache;
+            Aws::Set<Aws::String> m_keysUsed;
+            mutable std::mutex m_keysUsedMutex;
+            mutable bool m_shouldStopBackgroundRefresh;
+            Aws::UniquePtr<std::thread> m_backgroundRefreshThread;
+            mutable std::mutex m_shutDownMutex;
+            mutable std::condition_variable m_shutdownCondition;
+        };
+    }
+}

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ExpressSigner.h

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/s3/S3Errors.h>
+#include <aws/s3/S3ExpressIdentityProvider.h>
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/utils/ConcurrentCache.h>
+#include <aws/core/http/HttpRequest.h>
+
+namespace Aws {
+    namespace S3 {
+        class AWS_S3_API S3ExpressSigner : public Aws::Client::AWSAuthV4Signer {
+        public:
+            S3ExpressSigner(std::shared_ptr<S3ExpressIdentityProvider> S3ExpressIdentityProvider,
+                const std::shared_ptr<Auth::AWSCredentialsProvider> &credentialsProvider,
+                const Aws::String &serviceName,
+                const Aws::String &region,
+                PayloadSigningPolicy signingPolicy = PayloadSigningPolicy::RequestDependent,
+                bool urlEscapePath = true,
+                Aws::Auth::AWSSigningAlgorithm signingAlgorithm = Aws::Auth::AWSSigningAlgorithm::SIGV4);
+
+            virtual ~S3ExpressSigner() {};
+
+            const char *GetName() const override;
+
+            bool SignRequest(Aws::Http::HttpRequest &request,
+                const char *region,
+                const char *serviceName,
+                bool signBody
+            ) const override;
+
+            bool PresignRequest(Aws::Http::HttpRequest& request,
+                const char* region,
+                const char* serviceName,
+                long long expirationInSeconds
+            ) const override;
+
+            Aws::Auth::AWSCredentials GetCredentials(const std::shared_ptr<Aws::Http::ServiceSpecificParameters> &serviceSpecificParameters) const override;
+
+        protected:
+            bool ServiceRequireUnsignedPayload(const String &serviceName) const override;
+
+        private:
+            inline bool hasRequestId(const Aws::String &requestId) const {
+                std::lock_guard<std::mutex> lock(m_requestProcessing);
+                return m_requestsProcessing.find(requestId) != m_requestsProcessing.end();
+            }
+
+            inline void putRequestId(const Aws::String &requestId) const {
+                std::lock_guard<std::mutex> lock(m_requestProcessing);
+                m_requestsProcessing.insert(requestId);
+            }
+
+            inline void deleteRequestId(const Aws::String &requestId) const {
+                std::lock_guard<std::mutex> lock(m_requestProcessing);
+                m_requestsProcessing.erase(requestId);
+            }
+
+            std::shared_ptr<S3ExpressIdentityProvider> m_S3ExpressIdentityProvider;
+            std::shared_ptr<Auth::AWSCredentialsProvider> m_credentialsProvider;
+            mutable std::set<Aws::String> m_requestsProcessing;
+            mutable std::mutex m_requestProcessing;
+            const Aws::String m_serviceName;
+            const Aws::String m_region;
+            const Aws::String m_endpoint;
+        };
+    }
+}

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ExpressSignerProvider.h

@@ -0,0 +1,24 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#include <aws/core/auth/signer-provider/DefaultAuthSignerProvider.h>
+#include <aws/s3/S3ExpressIdentityProvider.h>
+
+
+namespace Aws {
+    namespace Auth {
+        class S3ExpressSignerProvider: public DefaultAuthSignerProvider {
+        public:
+            S3ExpressSignerProvider(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
+                const std::shared_ptr<S3::S3ExpressIdentityProvider>& S3ExpressIdentityProvider,
+                const Aws::String& serviceName,
+                const Aws::String& region,
+                Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy signingPolicy = Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::RequestDependent,
+                bool urlEscapePath = true);
+        };
+    }
+}

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3Request.h

@@ -0,0 +1,48 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/endpoint/AWSEndpoint.h>
+#include <aws/core/AmazonSerializableWebServiceRequest.h>
+#include <aws/core/utils/UnreferencedParam.h>
+#include <aws/core/http/HttpRequest.h>
+#include <aws/core/AmazonStreamingWebServiceRequest.h>
+
+namespace Aws
+{
+namespace S3
+{
+  class AWS_S3_API S3Request : public Aws::AmazonSerializableWebServiceRequest
+  {
+  public:
+    using EndpointParameter = Aws::Endpoint::EndpointParameter;
+    using EndpointParameters = Aws::Endpoint::EndpointParameters;
+
+    virtual ~S3Request () {}
+
+    void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
+
+    inline Aws::Http::HeaderValueCollection GetHeaders() const override
+    {
+      auto headers = GetRequestSpecificHeaders();
+
+      if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
+      {
+        headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_XML_CONTENT_TYPE ));
+      }
+      headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2006-03-01"));
+      return headers;
+    }
+
+  protected:
+    virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
+
+  };
+
+  typedef Aws::AmazonStreamingWebServiceRequest StreamingS3Request;
+
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3ServiceClientModel.h

@@ -0,0 +1,518 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+/* Generic header includes */
+#include <aws/s3/S3Errors.h>
+#include <aws/s3/S3ClientConfiguration.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/http/HttpTypes.h>
+#include <aws/s3/S3EndpointProvider.h>
+#include <future>
+#include <functional>
+/* End of generic header includes */
+
+/* Service model headers required in S3Client header */
+#include <aws/s3/model/AbortMultipartUploadResult.h>
+#include <aws/s3/model/CompleteMultipartUploadResult.h>
+#include <aws/s3/model/CopyObjectResult.h>
+#include <aws/s3/model/CreateBucketResult.h>
+#include <aws/s3/model/CreateMultipartUploadResult.h>
+#include <aws/s3/model/CreateSessionResult.h>
+#include <aws/s3/model/DeleteObjectResult.h>
+#include <aws/s3/model/DeleteObjectTaggingResult.h>
+#include <aws/s3/model/DeleteObjectsResult.h>
+#include <aws/s3/model/GetBucketAccelerateConfigurationResult.h>
+#include <aws/s3/model/GetBucketAclResult.h>
+#include <aws/s3/model/GetBucketAnalyticsConfigurationResult.h>
+#include <aws/s3/model/GetBucketCorsResult.h>
+#include <aws/s3/model/GetBucketEncryptionResult.h>
+#include <aws/s3/model/GetBucketIntelligentTieringConfigurationResult.h>
+#include <aws/s3/model/GetBucketInventoryConfigurationResult.h>
+#include <aws/s3/model/GetBucketLifecycleConfigurationResult.h>
+#include <aws/s3/model/GetBucketLocationResult.h>
+#include <aws/s3/model/GetBucketLoggingResult.h>
+#include <aws/s3/model/GetBucketMetricsConfigurationResult.h>
+#include <aws/s3/model/GetBucketNotificationConfigurationResult.h>
+#include <aws/s3/model/GetBucketOwnershipControlsResult.h>
+#include <aws/s3/model/GetBucketPolicyResult.h>
+#include <aws/s3/model/GetBucketPolicyStatusResult.h>
+#include <aws/s3/model/GetBucketReplicationResult.h>
+#include <aws/s3/model/GetBucketRequestPaymentResult.h>
+#include <aws/s3/model/GetBucketTaggingResult.h>
+#include <aws/s3/model/GetBucketVersioningResult.h>
+#include <aws/s3/model/GetBucketWebsiteResult.h>
+#include <aws/s3/model/GetObjectResult.h>
+#include <aws/s3/model/GetObjectAclResult.h>
+#include <aws/s3/model/GetObjectAttributesResult.h>
+#include <aws/s3/model/GetObjectLegalHoldResult.h>
+#include <aws/s3/model/GetObjectLockConfigurationResult.h>
+#include <aws/s3/model/GetObjectRetentionResult.h>
+#include <aws/s3/model/GetObjectTaggingResult.h>
+#include <aws/s3/model/GetObjectTorrentResult.h>
+#include <aws/s3/model/GetPublicAccessBlockResult.h>
+#include <aws/s3/model/HeadBucketResult.h>
+#include <aws/s3/model/HeadObjectResult.h>
+#include <aws/s3/model/ListBucketAnalyticsConfigurationsResult.h>
+#include <aws/s3/model/ListBucketIntelligentTieringConfigurationsResult.h>
+#include <aws/s3/model/ListBucketInventoryConfigurationsResult.h>
+#include <aws/s3/model/ListBucketMetricsConfigurationsResult.h>
+#include <aws/s3/model/ListBucketsResult.h>
+#include <aws/s3/model/ListDirectoryBucketsResult.h>
+#include <aws/s3/model/ListMultipartUploadsResult.h>
+#include <aws/s3/model/ListObjectVersionsResult.h>
+#include <aws/s3/model/ListObjectsResult.h>
+#include <aws/s3/model/ListObjectsV2Result.h>
+#include <aws/s3/model/ListPartsResult.h>
+#include <aws/s3/model/PutBucketLifecycleConfigurationResult.h>
+#include <aws/s3/model/PutObjectResult.h>
+#include <aws/s3/model/PutObjectAclResult.h>
+#include <aws/s3/model/PutObjectLegalHoldResult.h>
+#include <aws/s3/model/PutObjectLockConfigurationResult.h>
+#include <aws/s3/model/PutObjectRetentionResult.h>
+#include <aws/s3/model/PutObjectTaggingResult.h>
+#include <aws/s3/model/RestoreObjectResult.h>
+#include <aws/s3/model/UploadPartResult.h>
+#include <aws/s3/model/UploadPartCopyResult.h>
+#include <aws/s3/model/ListDirectoryBucketsRequest.h>
+#include <aws/s3/model/ListBucketsRequest.h>
+#include <aws/core/NoResult.h>
+/* End of service model headers required in S3Client header */
+
+namespace Aws
+{
+  namespace Http
+  {
+    class HttpClient;
+    class HttpClientFactory;
+  } // namespace Http
+
+  namespace Utils
+  {
+    template< typename R, typename E> class Outcome;
+
+    namespace Threading
+    {
+      class Executor;
+    } // namespace Threading
+  } // namespace Utils
+
+  namespace Auth
+  {
+    class AWSCredentials;
+    class AWSCredentialsProvider;
+  } // namespace Auth
+
+  namespace Client
+  {
+    class RetryStrategy;
+  } // namespace Client
+
+  namespace S3
+  {
+    using S3EndpointProviderBase = Aws::S3::Endpoint::S3EndpointProviderBase;
+    using S3EndpointProvider = Aws::S3::Endpoint::S3EndpointProvider;
+
+    namespace Model
+    {
+      /* Service model forward declarations required in S3Client header */
+      class AbortMultipartUploadRequest;
+      class CompleteMultipartUploadRequest;
+      class CopyObjectRequest;
+      class CreateBucketRequest;
+      class CreateMultipartUploadRequest;
+      class CreateSessionRequest;
+      class DeleteBucketRequest;
+      class DeleteBucketAnalyticsConfigurationRequest;
+      class DeleteBucketCorsRequest;
+      class DeleteBucketEncryptionRequest;
+      class DeleteBucketIntelligentTieringConfigurationRequest;
+      class DeleteBucketInventoryConfigurationRequest;
+      class DeleteBucketLifecycleRequest;
+      class DeleteBucketMetricsConfigurationRequest;
+      class DeleteBucketOwnershipControlsRequest;
+      class DeleteBucketPolicyRequest;
+      class DeleteBucketReplicationRequest;
+      class DeleteBucketTaggingRequest;
+      class DeleteBucketWebsiteRequest;
+      class DeleteObjectRequest;
+      class DeleteObjectTaggingRequest;
+      class DeleteObjectsRequest;
+      class DeletePublicAccessBlockRequest;
+      class GetBucketAccelerateConfigurationRequest;
+      class GetBucketAclRequest;
+      class GetBucketAnalyticsConfigurationRequest;
+      class GetBucketCorsRequest;
+      class GetBucketEncryptionRequest;
+      class GetBucketIntelligentTieringConfigurationRequest;
+      class GetBucketInventoryConfigurationRequest;
+      class GetBucketLifecycleConfigurationRequest;
+      class GetBucketLocationRequest;
+      class GetBucketLoggingRequest;
+      class GetBucketMetricsConfigurationRequest;
+      class GetBucketNotificationConfigurationRequest;
+      class GetBucketOwnershipControlsRequest;
+      class GetBucketPolicyRequest;
+      class GetBucketPolicyStatusRequest;
+      class GetBucketReplicationRequest;
+      class GetBucketRequestPaymentRequest;
+      class GetBucketTaggingRequest;
+      class GetBucketVersioningRequest;
+      class GetBucketWebsiteRequest;
+      class GetObjectRequest;
+      class GetObjectAclRequest;
+      class GetObjectAttributesRequest;
+      class GetObjectLegalHoldRequest;
+      class GetObjectLockConfigurationRequest;
+      class GetObjectRetentionRequest;
+      class GetObjectTaggingRequest;
+      class GetObjectTorrentRequest;
+      class GetPublicAccessBlockRequest;
+      class HeadBucketRequest;
+      class HeadObjectRequest;
+      class ListBucketAnalyticsConfigurationsRequest;
+      class ListBucketIntelligentTieringConfigurationsRequest;
+      class ListBucketInventoryConfigurationsRequest;
+      class ListBucketMetricsConfigurationsRequest;
+      class ListBucketsRequest;
+      class ListDirectoryBucketsRequest;
+      class ListMultipartUploadsRequest;
+      class ListObjectVersionsRequest;
+      class ListObjectsRequest;
+      class ListObjectsV2Request;
+      class ListPartsRequest;
+      class PutBucketAccelerateConfigurationRequest;
+      class PutBucketAclRequest;
+      class PutBucketAnalyticsConfigurationRequest;
+      class PutBucketCorsRequest;
+      class PutBucketEncryptionRequest;
+      class PutBucketIntelligentTieringConfigurationRequest;
+      class PutBucketInventoryConfigurationRequest;
+      class PutBucketLifecycleConfigurationRequest;
+      class PutBucketLoggingRequest;
+      class PutBucketMetricsConfigurationRequest;
+      class PutBucketNotificationConfigurationRequest;
+      class PutBucketOwnershipControlsRequest;
+      class PutBucketPolicyRequest;
+      class PutBucketReplicationRequest;
+      class PutBucketRequestPaymentRequest;
+      class PutBucketTaggingRequest;
+      class PutBucketVersioningRequest;
+      class PutBucketWebsiteRequest;
+      class PutObjectRequest;
+      class PutObjectAclRequest;
+      class PutObjectLegalHoldRequest;
+      class PutObjectLockConfigurationRequest;
+      class PutObjectRetentionRequest;
+      class PutObjectTaggingRequest;
+      class PutPublicAccessBlockRequest;
+      class RestoreObjectRequest;
+      class SelectObjectContentRequest;
+      class UploadPartRequest;
+      class UploadPartCopyRequest;
+      class WriteGetObjectResponseRequest;
+      /* End of service model forward declarations required in S3Client header */
+
+      /* Service model Outcome class definitions */
+      typedef Aws::Utils::Outcome<AbortMultipartUploadResult, S3Error> AbortMultipartUploadOutcome;
+      typedef Aws::Utils::Outcome<CompleteMultipartUploadResult, S3Error> CompleteMultipartUploadOutcome;
+      typedef Aws::Utils::Outcome<CopyObjectResult, S3Error> CopyObjectOutcome;
+      typedef Aws::Utils::Outcome<CreateBucketResult, S3Error> CreateBucketOutcome;
+      typedef Aws::Utils::Outcome<CreateMultipartUploadResult, S3Error> CreateMultipartUploadOutcome;
+      typedef Aws::Utils::Outcome<CreateSessionResult, S3Error> CreateSessionOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketAnalyticsConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketCorsOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketEncryptionOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketIntelligentTieringConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketInventoryConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketLifecycleOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketMetricsConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketOwnershipControlsOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketPolicyOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketReplicationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketTaggingOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeleteBucketWebsiteOutcome;
+      typedef Aws::Utils::Outcome<DeleteObjectResult, S3Error> DeleteObjectOutcome;
+      typedef Aws::Utils::Outcome<DeleteObjectTaggingResult, S3Error> DeleteObjectTaggingOutcome;
+      typedef Aws::Utils::Outcome<DeleteObjectsResult, S3Error> DeleteObjectsOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> DeletePublicAccessBlockOutcome;
+      typedef Aws::Utils::Outcome<GetBucketAccelerateConfigurationResult, S3Error> GetBucketAccelerateConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketAclResult, S3Error> GetBucketAclOutcome;
+      typedef Aws::Utils::Outcome<GetBucketAnalyticsConfigurationResult, S3Error> GetBucketAnalyticsConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketCorsResult, S3Error> GetBucketCorsOutcome;
+      typedef Aws::Utils::Outcome<GetBucketEncryptionResult, S3Error> GetBucketEncryptionOutcome;
+      typedef Aws::Utils::Outcome<GetBucketIntelligentTieringConfigurationResult, S3Error> GetBucketIntelligentTieringConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketInventoryConfigurationResult, S3Error> GetBucketInventoryConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketLifecycleConfigurationResult, S3Error> GetBucketLifecycleConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketLocationResult, S3Error> GetBucketLocationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketLoggingResult, S3Error> GetBucketLoggingOutcome;
+      typedef Aws::Utils::Outcome<GetBucketMetricsConfigurationResult, S3Error> GetBucketMetricsConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketNotificationConfigurationResult, S3Error> GetBucketNotificationConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketOwnershipControlsResult, S3Error> GetBucketOwnershipControlsOutcome;
+      typedef Aws::Utils::Outcome<GetBucketPolicyResult, S3Error> GetBucketPolicyOutcome;
+      typedef Aws::Utils::Outcome<GetBucketPolicyStatusResult, S3Error> GetBucketPolicyStatusOutcome;
+      typedef Aws::Utils::Outcome<GetBucketReplicationResult, S3Error> GetBucketReplicationOutcome;
+      typedef Aws::Utils::Outcome<GetBucketRequestPaymentResult, S3Error> GetBucketRequestPaymentOutcome;
+      typedef Aws::Utils::Outcome<GetBucketTaggingResult, S3Error> GetBucketTaggingOutcome;
+      typedef Aws::Utils::Outcome<GetBucketVersioningResult, S3Error> GetBucketVersioningOutcome;
+      typedef Aws::Utils::Outcome<GetBucketWebsiteResult, S3Error> GetBucketWebsiteOutcome;
+      typedef Aws::Utils::Outcome<GetObjectResult, S3Error> GetObjectOutcome;
+      typedef Aws::Utils::Outcome<GetObjectAclResult, S3Error> GetObjectAclOutcome;
+      typedef Aws::Utils::Outcome<GetObjectAttributesResult, S3Error> GetObjectAttributesOutcome;
+      typedef Aws::Utils::Outcome<GetObjectLegalHoldResult, S3Error> GetObjectLegalHoldOutcome;
+      typedef Aws::Utils::Outcome<GetObjectLockConfigurationResult, S3Error> GetObjectLockConfigurationOutcome;
+      typedef Aws::Utils::Outcome<GetObjectRetentionResult, S3Error> GetObjectRetentionOutcome;
+      typedef Aws::Utils::Outcome<GetObjectTaggingResult, S3Error> GetObjectTaggingOutcome;
+      typedef Aws::Utils::Outcome<GetObjectTorrentResult, S3Error> GetObjectTorrentOutcome;
+      typedef Aws::Utils::Outcome<GetPublicAccessBlockResult, S3Error> GetPublicAccessBlockOutcome;
+      typedef Aws::Utils::Outcome<HeadBucketResult, S3Error> HeadBucketOutcome;
+      typedef Aws::Utils::Outcome<HeadObjectResult, S3Error> HeadObjectOutcome;
+      typedef Aws::Utils::Outcome<ListBucketAnalyticsConfigurationsResult, S3Error> ListBucketAnalyticsConfigurationsOutcome;
+      typedef Aws::Utils::Outcome<ListBucketIntelligentTieringConfigurationsResult, S3Error> ListBucketIntelligentTieringConfigurationsOutcome;
+      typedef Aws::Utils::Outcome<ListBucketInventoryConfigurationsResult, S3Error> ListBucketInventoryConfigurationsOutcome;
+      typedef Aws::Utils::Outcome<ListBucketMetricsConfigurationsResult, S3Error> ListBucketMetricsConfigurationsOutcome;
+      typedef Aws::Utils::Outcome<ListBucketsResult, S3Error> ListBucketsOutcome;
+      typedef Aws::Utils::Outcome<ListDirectoryBucketsResult, S3Error> ListDirectoryBucketsOutcome;
+      typedef Aws::Utils::Outcome<ListMultipartUploadsResult, S3Error> ListMultipartUploadsOutcome;
+      typedef Aws::Utils::Outcome<ListObjectVersionsResult, S3Error> ListObjectVersionsOutcome;
+      typedef Aws::Utils::Outcome<ListObjectsResult, S3Error> ListObjectsOutcome;
+      typedef Aws::Utils::Outcome<ListObjectsV2Result, S3Error> ListObjectsV2Outcome;
+      typedef Aws::Utils::Outcome<ListPartsResult, S3Error> ListPartsOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketAccelerateConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketAclOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketAnalyticsConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketCorsOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketEncryptionOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketIntelligentTieringConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketInventoryConfigurationOutcome;
+      typedef Aws::Utils::Outcome<PutBucketLifecycleConfigurationResult, S3Error> PutBucketLifecycleConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketLoggingOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketMetricsConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketNotificationConfigurationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketOwnershipControlsOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketPolicyOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketReplicationOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketRequestPaymentOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketTaggingOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketVersioningOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutBucketWebsiteOutcome;
+      typedef Aws::Utils::Outcome<PutObjectResult, S3Error> PutObjectOutcome;
+      typedef Aws::Utils::Outcome<PutObjectAclResult, S3Error> PutObjectAclOutcome;
+      typedef Aws::Utils::Outcome<PutObjectLegalHoldResult, S3Error> PutObjectLegalHoldOutcome;
+      typedef Aws::Utils::Outcome<PutObjectLockConfigurationResult, S3Error> PutObjectLockConfigurationOutcome;
+      typedef Aws::Utils::Outcome<PutObjectRetentionResult, S3Error> PutObjectRetentionOutcome;
+      typedef Aws::Utils::Outcome<PutObjectTaggingResult, S3Error> PutObjectTaggingOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> PutPublicAccessBlockOutcome;
+      typedef Aws::Utils::Outcome<RestoreObjectResult, S3Error> RestoreObjectOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> SelectObjectContentOutcome;
+      typedef Aws::Utils::Outcome<UploadPartResult, S3Error> UploadPartOutcome;
+      typedef Aws::Utils::Outcome<UploadPartCopyResult, S3Error> UploadPartCopyOutcome;
+      typedef Aws::Utils::Outcome<Aws::NoResult, S3Error> WriteGetObjectResponseOutcome;
+      /* End of service model Outcome class definitions */
+
+      /* Service model Outcome callable definitions */
+      typedef std::future<AbortMultipartUploadOutcome> AbortMultipartUploadOutcomeCallable;
+      typedef std::future<CompleteMultipartUploadOutcome> CompleteMultipartUploadOutcomeCallable;
+      typedef std::future<CopyObjectOutcome> CopyObjectOutcomeCallable;
+      typedef std::future<CreateBucketOutcome> CreateBucketOutcomeCallable;
+      typedef std::future<CreateMultipartUploadOutcome> CreateMultipartUploadOutcomeCallable;
+      typedef std::future<CreateSessionOutcome> CreateSessionOutcomeCallable;
+      typedef std::future<DeleteBucketOutcome> DeleteBucketOutcomeCallable;
+      typedef std::future<DeleteBucketAnalyticsConfigurationOutcome> DeleteBucketAnalyticsConfigurationOutcomeCallable;
+      typedef std::future<DeleteBucketCorsOutcome> DeleteBucketCorsOutcomeCallable;
+      typedef std::future<DeleteBucketEncryptionOutcome> DeleteBucketEncryptionOutcomeCallable;
+      typedef std::future<DeleteBucketIntelligentTieringConfigurationOutcome> DeleteBucketIntelligentTieringConfigurationOutcomeCallable;
+      typedef std::future<DeleteBucketInventoryConfigurationOutcome> DeleteBucketInventoryConfigurationOutcomeCallable;
+      typedef std::future<DeleteBucketLifecycleOutcome> DeleteBucketLifecycleOutcomeCallable;
+      typedef std::future<DeleteBucketMetricsConfigurationOutcome> DeleteBucketMetricsConfigurationOutcomeCallable;
+      typedef std::future<DeleteBucketOwnershipControlsOutcome> DeleteBucketOwnershipControlsOutcomeCallable;
+      typedef std::future<DeleteBucketPolicyOutcome> DeleteBucketPolicyOutcomeCallable;
+      typedef std::future<DeleteBucketReplicationOutcome> DeleteBucketReplicationOutcomeCallable;
+      typedef std::future<DeleteBucketTaggingOutcome> DeleteBucketTaggingOutcomeCallable;
+      typedef std::future<DeleteBucketWebsiteOutcome> DeleteBucketWebsiteOutcomeCallable;
+      typedef std::future<DeleteObjectOutcome> DeleteObjectOutcomeCallable;
+      typedef std::future<DeleteObjectTaggingOutcome> DeleteObjectTaggingOutcomeCallable;
+      typedef std::future<DeleteObjectsOutcome> DeleteObjectsOutcomeCallable;
+      typedef std::future<DeletePublicAccessBlockOutcome> DeletePublicAccessBlockOutcomeCallable;
+      typedef std::future<GetBucketAccelerateConfigurationOutcome> GetBucketAccelerateConfigurationOutcomeCallable;
+      typedef std::future<GetBucketAclOutcome> GetBucketAclOutcomeCallable;
+      typedef std::future<GetBucketAnalyticsConfigurationOutcome> GetBucketAnalyticsConfigurationOutcomeCallable;
+      typedef std::future<GetBucketCorsOutcome> GetBucketCorsOutcomeCallable;
+      typedef std::future<GetBucketEncryptionOutcome> GetBucketEncryptionOutcomeCallable;
+      typedef std::future<GetBucketIntelligentTieringConfigurationOutcome> GetBucketIntelligentTieringConfigurationOutcomeCallable;
+      typedef std::future<GetBucketInventoryConfigurationOutcome> GetBucketInventoryConfigurationOutcomeCallable;
+      typedef std::future<GetBucketLifecycleConfigurationOutcome> GetBucketLifecycleConfigurationOutcomeCallable;
+      typedef std::future<GetBucketLocationOutcome> GetBucketLocationOutcomeCallable;
+      typedef std::future<GetBucketLoggingOutcome> GetBucketLoggingOutcomeCallable;
+      typedef std::future<GetBucketMetricsConfigurationOutcome> GetBucketMetricsConfigurationOutcomeCallable;
+      typedef std::future<GetBucketNotificationConfigurationOutcome> GetBucketNotificationConfigurationOutcomeCallable;
+      typedef std::future<GetBucketOwnershipControlsOutcome> GetBucketOwnershipControlsOutcomeCallable;
+      typedef std::future<GetBucketPolicyOutcome> GetBucketPolicyOutcomeCallable;
+      typedef std::future<GetBucketPolicyStatusOutcome> GetBucketPolicyStatusOutcomeCallable;
+      typedef std::future<GetBucketReplicationOutcome> GetBucketReplicationOutcomeCallable;
+      typedef std::future<GetBucketRequestPaymentOutcome> GetBucketRequestPaymentOutcomeCallable;
+      typedef std::future<GetBucketTaggingOutcome> GetBucketTaggingOutcomeCallable;
+      typedef std::future<GetBucketVersioningOutcome> GetBucketVersioningOutcomeCallable;
+      typedef std::future<GetBucketWebsiteOutcome> GetBucketWebsiteOutcomeCallable;
+      typedef std::future<GetObjectOutcome> GetObjectOutcomeCallable;
+      typedef std::future<GetObjectAclOutcome> GetObjectAclOutcomeCallable;
+      typedef std::future<GetObjectAttributesOutcome> GetObjectAttributesOutcomeCallable;
+      typedef std::future<GetObjectLegalHoldOutcome> GetObjectLegalHoldOutcomeCallable;
+      typedef std::future<GetObjectLockConfigurationOutcome> GetObjectLockConfigurationOutcomeCallable;
+      typedef std::future<GetObjectRetentionOutcome> GetObjectRetentionOutcomeCallable;
+      typedef std::future<GetObjectTaggingOutcome> GetObjectTaggingOutcomeCallable;
+      typedef std::future<GetObjectTorrentOutcome> GetObjectTorrentOutcomeCallable;
+      typedef std::future<GetPublicAccessBlockOutcome> GetPublicAccessBlockOutcomeCallable;
+      typedef std::future<HeadBucketOutcome> HeadBucketOutcomeCallable;
+      typedef std::future<HeadObjectOutcome> HeadObjectOutcomeCallable;
+      typedef std::future<ListBucketAnalyticsConfigurationsOutcome> ListBucketAnalyticsConfigurationsOutcomeCallable;
+      typedef std::future<ListBucketIntelligentTieringConfigurationsOutcome> ListBucketIntelligentTieringConfigurationsOutcomeCallable;
+      typedef std::future<ListBucketInventoryConfigurationsOutcome> ListBucketInventoryConfigurationsOutcomeCallable;
+      typedef std::future<ListBucketMetricsConfigurationsOutcome> ListBucketMetricsConfigurationsOutcomeCallable;
+      typedef std::future<ListBucketsOutcome> ListBucketsOutcomeCallable;
+      typedef std::future<ListDirectoryBucketsOutcome> ListDirectoryBucketsOutcomeCallable;
+      typedef std::future<ListMultipartUploadsOutcome> ListMultipartUploadsOutcomeCallable;
+      typedef std::future<ListObjectVersionsOutcome> ListObjectVersionsOutcomeCallable;
+      typedef std::future<ListObjectsOutcome> ListObjectsOutcomeCallable;
+      typedef std::future<ListObjectsV2Outcome> ListObjectsV2OutcomeCallable;
+      typedef std::future<ListPartsOutcome> ListPartsOutcomeCallable;
+      typedef std::future<PutBucketAccelerateConfigurationOutcome> PutBucketAccelerateConfigurationOutcomeCallable;
+      typedef std::future<PutBucketAclOutcome> PutBucketAclOutcomeCallable;
+      typedef std::future<PutBucketAnalyticsConfigurationOutcome> PutBucketAnalyticsConfigurationOutcomeCallable;
+      typedef std::future<PutBucketCorsOutcome> PutBucketCorsOutcomeCallable;
+      typedef std::future<PutBucketEncryptionOutcome> PutBucketEncryptionOutcomeCallable;
+      typedef std::future<PutBucketIntelligentTieringConfigurationOutcome> PutBucketIntelligentTieringConfigurationOutcomeCallable;
+      typedef std::future<PutBucketInventoryConfigurationOutcome> PutBucketInventoryConfigurationOutcomeCallable;
+      typedef std::future<PutBucketLifecycleConfigurationOutcome> PutBucketLifecycleConfigurationOutcomeCallable;
+      typedef std::future<PutBucketLoggingOutcome> PutBucketLoggingOutcomeCallable;
+      typedef std::future<PutBucketMetricsConfigurationOutcome> PutBucketMetricsConfigurationOutcomeCallable;
+      typedef std::future<PutBucketNotificationConfigurationOutcome> PutBucketNotificationConfigurationOutcomeCallable;
+      typedef std::future<PutBucketOwnershipControlsOutcome> PutBucketOwnershipControlsOutcomeCallable;
+      typedef std::future<PutBucketPolicyOutcome> PutBucketPolicyOutcomeCallable;
+      typedef std::future<PutBucketReplicationOutcome> PutBucketReplicationOutcomeCallable;
+      typedef std::future<PutBucketRequestPaymentOutcome> PutBucketRequestPaymentOutcomeCallable;
+      typedef std::future<PutBucketTaggingOutcome> PutBucketTaggingOutcomeCallable;
+      typedef std::future<PutBucketVersioningOutcome> PutBucketVersioningOutcomeCallable;
+      typedef std::future<PutBucketWebsiteOutcome> PutBucketWebsiteOutcomeCallable;
+      typedef std::future<PutObjectOutcome> PutObjectOutcomeCallable;
+      typedef std::future<PutObjectAclOutcome> PutObjectAclOutcomeCallable;
+      typedef std::future<PutObjectLegalHoldOutcome> PutObjectLegalHoldOutcomeCallable;
+      typedef std::future<PutObjectLockConfigurationOutcome> PutObjectLockConfigurationOutcomeCallable;
+      typedef std::future<PutObjectRetentionOutcome> PutObjectRetentionOutcomeCallable;
+      typedef std::future<PutObjectTaggingOutcome> PutObjectTaggingOutcomeCallable;
+      typedef std::future<PutPublicAccessBlockOutcome> PutPublicAccessBlockOutcomeCallable;
+      typedef std::future<RestoreObjectOutcome> RestoreObjectOutcomeCallable;
+      typedef std::future<SelectObjectContentOutcome> SelectObjectContentOutcomeCallable;
+      typedef std::future<UploadPartOutcome> UploadPartOutcomeCallable;
+      typedef std::future<UploadPartCopyOutcome> UploadPartCopyOutcomeCallable;
+      typedef std::future<WriteGetObjectResponseOutcome> WriteGetObjectResponseOutcomeCallable;
+      /* End of service model Outcome callable definitions */
+    } // namespace Model
+
+    class S3Client;
+
+    /* Service model async handlers definitions */
+    typedef std::function<void(const S3Client*, const Model::AbortMultipartUploadRequest&, const Model::AbortMultipartUploadOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AbortMultipartUploadResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::CompleteMultipartUploadRequest&, const Model::CompleteMultipartUploadOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CompleteMultipartUploadResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::CopyObjectRequest&, const Model::CopyObjectOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CopyObjectResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::CreateBucketRequest&, const Model::CreateBucketOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateBucketResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::CreateMultipartUploadRequest&, const Model::CreateMultipartUploadOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateMultipartUploadResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::CreateSessionRequest&, const Model::CreateSessionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateSessionResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketRequest&, const Model::DeleteBucketOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketAnalyticsConfigurationRequest&, const Model::DeleteBucketAnalyticsConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketAnalyticsConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketCorsRequest&, const Model::DeleteBucketCorsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketCorsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketEncryptionRequest&, const Model::DeleteBucketEncryptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketEncryptionResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketIntelligentTieringConfigurationRequest&, const Model::DeleteBucketIntelligentTieringConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketIntelligentTieringConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketInventoryConfigurationRequest&, const Model::DeleteBucketInventoryConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketInventoryConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketLifecycleRequest&, const Model::DeleteBucketLifecycleOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketLifecycleResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketMetricsConfigurationRequest&, const Model::DeleteBucketMetricsConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketMetricsConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketOwnershipControlsRequest&, const Model::DeleteBucketOwnershipControlsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketOwnershipControlsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketPolicyRequest&, const Model::DeleteBucketPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketPolicyResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketReplicationRequest&, const Model::DeleteBucketReplicationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketReplicationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketTaggingRequest&, const Model::DeleteBucketTaggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketTaggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteBucketWebsiteRequest&, const Model::DeleteBucketWebsiteOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBucketWebsiteResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteObjectRequest&, const Model::DeleteObjectOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteObjectResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteObjectTaggingRequest&, const Model::DeleteObjectTaggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteObjectTaggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeleteObjectsRequest&, const Model::DeleteObjectsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteObjectsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::DeletePublicAccessBlockRequest&, const Model::DeletePublicAccessBlockOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeletePublicAccessBlockResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketAccelerateConfigurationRequest&, const Model::GetBucketAccelerateConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketAccelerateConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketAclRequest&, const Model::GetBucketAclOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketAclResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketAnalyticsConfigurationRequest&, const Model::GetBucketAnalyticsConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketAnalyticsConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketCorsRequest&, const Model::GetBucketCorsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketCorsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketEncryptionRequest&, const Model::GetBucketEncryptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketEncryptionResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketIntelligentTieringConfigurationRequest&, const Model::GetBucketIntelligentTieringConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketIntelligentTieringConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketInventoryConfigurationRequest&, const Model::GetBucketInventoryConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketInventoryConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketLifecycleConfigurationRequest&, const Model::GetBucketLifecycleConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketLifecycleConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketLocationRequest&, const Model::GetBucketLocationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketLocationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketLoggingRequest&, const Model::GetBucketLoggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketLoggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketMetricsConfigurationRequest&, const Model::GetBucketMetricsConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketMetricsConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketNotificationConfigurationRequest&, const Model::GetBucketNotificationConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketNotificationConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketOwnershipControlsRequest&, const Model::GetBucketOwnershipControlsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketOwnershipControlsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketPolicyRequest&, Model::GetBucketPolicyOutcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketPolicyResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketPolicyStatusRequest&, const Model::GetBucketPolicyStatusOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketPolicyStatusResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketReplicationRequest&, const Model::GetBucketReplicationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketReplicationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketRequestPaymentRequest&, const Model::GetBucketRequestPaymentOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketRequestPaymentResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketTaggingRequest&, const Model::GetBucketTaggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketTaggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketVersioningRequest&, const Model::GetBucketVersioningOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketVersioningResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetBucketWebsiteRequest&, const Model::GetBucketWebsiteOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetBucketWebsiteResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectRequest&, Model::GetObjectOutcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectAclRequest&, const Model::GetObjectAclOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectAclResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectAttributesRequest&, const Model::GetObjectAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectAttributesResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectLegalHoldRequest&, const Model::GetObjectLegalHoldOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectLegalHoldResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectLockConfigurationRequest&, const Model::GetObjectLockConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectLockConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectRetentionRequest&, const Model::GetObjectRetentionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectRetentionResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectTaggingRequest&, const Model::GetObjectTaggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectTaggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetObjectTorrentRequest&, Model::GetObjectTorrentOutcome, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetObjectTorrentResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::GetPublicAccessBlockRequest&, const Model::GetPublicAccessBlockOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetPublicAccessBlockResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::HeadBucketRequest&, const Model::HeadBucketOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > HeadBucketResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::HeadObjectRequest&, const Model::HeadObjectOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > HeadObjectResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListBucketAnalyticsConfigurationsRequest&, const Model::ListBucketAnalyticsConfigurationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBucketAnalyticsConfigurationsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListBucketIntelligentTieringConfigurationsRequest&, const Model::ListBucketIntelligentTieringConfigurationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBucketIntelligentTieringConfigurationsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListBucketInventoryConfigurationsRequest&, const Model::ListBucketInventoryConfigurationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBucketInventoryConfigurationsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListBucketMetricsConfigurationsRequest&, const Model::ListBucketMetricsConfigurationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBucketMetricsConfigurationsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListBucketsRequest&, const Model::ListBucketsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBucketsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListDirectoryBucketsRequest&, const Model::ListDirectoryBucketsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListDirectoryBucketsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListMultipartUploadsRequest&, const Model::ListMultipartUploadsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListMultipartUploadsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListObjectVersionsRequest&, const Model::ListObjectVersionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListObjectVersionsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListObjectsRequest&, const Model::ListObjectsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListObjectsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListObjectsV2Request&, const Model::ListObjectsV2Outcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListObjectsV2ResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::ListPartsRequest&, const Model::ListPartsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListPartsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketAccelerateConfigurationRequest&, const Model::PutBucketAccelerateConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketAccelerateConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketAclRequest&, const Model::PutBucketAclOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketAclResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketAnalyticsConfigurationRequest&, const Model::PutBucketAnalyticsConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketAnalyticsConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketCorsRequest&, const Model::PutBucketCorsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketCorsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketEncryptionRequest&, const Model::PutBucketEncryptionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketEncryptionResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketIntelligentTieringConfigurationRequest&, const Model::PutBucketIntelligentTieringConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketIntelligentTieringConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketInventoryConfigurationRequest&, const Model::PutBucketInventoryConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketInventoryConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketLifecycleConfigurationRequest&, const Model::PutBucketLifecycleConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketLifecycleConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketLoggingRequest&, const Model::PutBucketLoggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketLoggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketMetricsConfigurationRequest&, const Model::PutBucketMetricsConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketMetricsConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketNotificationConfigurationRequest&, const Model::PutBucketNotificationConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketNotificationConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketOwnershipControlsRequest&, const Model::PutBucketOwnershipControlsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketOwnershipControlsResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketPolicyRequest&, const Model::PutBucketPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketPolicyResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketReplicationRequest&, const Model::PutBucketReplicationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketReplicationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketRequestPaymentRequest&, const Model::PutBucketRequestPaymentOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketRequestPaymentResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketTaggingRequest&, const Model::PutBucketTaggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketTaggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketVersioningRequest&, const Model::PutBucketVersioningOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketVersioningResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutBucketWebsiteRequest&, const Model::PutBucketWebsiteOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutBucketWebsiteResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutObjectRequest&, const Model::PutObjectOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutObjectResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutObjectAclRequest&, const Model::PutObjectAclOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutObjectAclResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutObjectLegalHoldRequest&, const Model::PutObjectLegalHoldOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutObjectLegalHoldResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutObjectLockConfigurationRequest&, const Model::PutObjectLockConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutObjectLockConfigurationResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutObjectRetentionRequest&, const Model::PutObjectRetentionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutObjectRetentionResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutObjectTaggingRequest&, const Model::PutObjectTaggingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutObjectTaggingResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::PutPublicAccessBlockRequest&, const Model::PutPublicAccessBlockOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutPublicAccessBlockResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::RestoreObjectRequest&, const Model::RestoreObjectOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RestoreObjectResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::SelectObjectContentRequest&, const Model::SelectObjectContentOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SelectObjectContentResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::UploadPartRequest&, const Model::UploadPartOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UploadPartResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::UploadPartCopyRequest&, const Model::UploadPartCopyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UploadPartCopyResponseReceivedHandler;
+    typedef std::function<void(const S3Client*, const Model::WriteGetObjectResponseRequest&, const Model::WriteGetObjectResponseOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > WriteGetObjectResponseResponseReceivedHandler;
+    /* End of service model async handlers definitions */
+  } // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/S3_EXPORTS.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+
+#ifdef _MSC_VER
+    //disable windows complaining about max template size.
+    #pragma warning (disable : 4503)
+#endif // _MSC_VER
+
+#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
+    #ifdef _MSC_VER
+        #pragma warning(disable : 4251)
+    #endif // _MSC_VER
+
+    #ifdef USE_IMPORT_EXPORT
+        #ifdef AWS_S3_EXPORTS
+            #define AWS_S3_API __declspec(dllexport)
+        #else
+            #define AWS_S3_API __declspec(dllimport)
+        #endif /* AWS_S3_EXPORTS */
+        #define AWS_S3_EXTERN
+    #else
+        #define AWS_S3_API
+        #define AWS_S3_EXTERN extern
+    #endif // USE_IMPORT_EXPORT
+#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
+    #define AWS_S3_API
+    #define AWS_S3_EXTERN extern
+#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/exports.h

@@ -0,0 +1,29 @@
+#ifndef AWS_S3_EXPORTS_H
+#define AWS_S3_EXPORTS_H
+
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#if defined(USE_WINDOWS_DLL_SEMANTICS) || defined(WIN32)
+#    ifdef AWS_S3_USE_IMPORT_EXPORT
+#        ifdef AWS_S3_EXPORTS
+#            define AWS_S3_API __declspec(dllexport)
+#        else
+#            define AWS_S3_API __declspec(dllimport)
+#        endif /* AWS_S3_EXPORTS */
+#    else
+#        define AWS_S3_API
+#    endif /*USE_IMPORT_EXPORT */
+
+#else
+#    if ((__GNUC__ >= 4) || defined(__clang__)) && defined(AWS_S3_USE_IMPORT_EXPORT) && defined(AWS_S3_EXPORTS)
+#        define AWS_S3_API __attribute__((visibility("default")))
+#    else
+#        define AWS_S3_API
+#    endif /* __GNUC__ >= 4 || defined(__clang__) */
+
+#endif /* defined(USE_WINDOWS_DLL_SEMANTICS) || defined(WIN32) */
+
+#endif /* AWS_S3_EXPORTS_H */

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AbortIncompleteMultipartUpload.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies the days since the initiation of an incomplete multipart upload
+   * that Amazon S3 will wait before permanently removing all parts of the upload.
+   * For more information, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config">
+   * Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Configuration</a>
+   * in the <i>Amazon S3 User Guide</i>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AbortIncompleteMultipartUpload">AWS
+   * API Reference</a></p>
+   */
+  class AbortIncompleteMultipartUpload
+  {
+  public:
+    AWS_S3_API AbortIncompleteMultipartUpload();
+    AWS_S3_API AbortIncompleteMultipartUpload(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AbortIncompleteMultipartUpload& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies the number of days after which Amazon S3 aborts an incomplete
+     * multipart upload.</p>
+     */
+    inline int GetDaysAfterInitiation() const{ return m_daysAfterInitiation; }
+    inline bool DaysAfterInitiationHasBeenSet() const { return m_daysAfterInitiationHasBeenSet; }
+    inline void SetDaysAfterInitiation(int value) { m_daysAfterInitiationHasBeenSet = true; m_daysAfterInitiation = value; }
+    inline AbortIncompleteMultipartUpload& WithDaysAfterInitiation(int value) { SetDaysAfterInitiation(value); return *this;}
+    ///@}
+  private:
+
+    int m_daysAfterInitiation;
+    bool m_daysAfterInitiationHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AbortMultipartUploadRequest.h

@@ -0,0 +1,187 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/RequestPayer.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class AbortMultipartUploadRequest : public S3Request
+  {
+  public:
+    AWS_S3_API AbortMultipartUploadRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "AbortMultipartUpload"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name to which the upload was taking place. </p> <p> <b>Directory
+     * buckets</b> - When you use this operation with a directory bucket, you must use
+     * virtual-hosted-style requests in the format <code>
+     * <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>.
+     * Path-style requests are not supported. Directory bucket names must be unique in
+     * the chosen Availability Zone. Bucket names must follow the format <code>
+     * <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>
+     * <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about
+     * bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Access
+     * points</b> - When you use this action with an access point, you must provide the
+     * alias of the access point in place of the bucket name or specify the access
+     * point ARN. When using the access point ARN, you must direct requests to the
+     * access point hostname. The access point hostname takes the form
+     * <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com.
+     * When using this action with an access point through the Amazon Web Services
+     * SDKs, you provide the access point ARN in place of the bucket name. For more
+     * information about access point ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using
+     * access points</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>Access
+     * points and Object Lambda access points are not supported by directory
+     * buckets.</p>  <p> <b>S3 on Outposts</b> - When you use this action with
+     * Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname.
+     * The S3 on Outposts hostname takes the form <code>
+     * <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>.
+     * When you use this action with S3 on Outposts through the Amazon Web Services
+     * SDKs, you provide the Outposts access point ARN in place of the bucket name. For
+     * more information about S3 on Outposts ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What
+     * is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline AbortMultipartUploadRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline AbortMultipartUploadRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline AbortMultipartUploadRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Key of the object for which the multipart upload was initiated.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline AbortMultipartUploadRequest& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline AbortMultipartUploadRequest& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline AbortMultipartUploadRequest& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Upload ID that identifies the multipart upload.</p>
+     */
+    inline const Aws::String& GetUploadId() const{ return m_uploadId; }
+    inline bool UploadIdHasBeenSet() const { return m_uploadIdHasBeenSet; }
+    inline void SetUploadId(const Aws::String& value) { m_uploadIdHasBeenSet = true; m_uploadId = value; }
+    inline void SetUploadId(Aws::String&& value) { m_uploadIdHasBeenSet = true; m_uploadId = std::move(value); }
+    inline void SetUploadId(const char* value) { m_uploadIdHasBeenSet = true; m_uploadId.assign(value); }
+    inline AbortMultipartUploadRequest& WithUploadId(const Aws::String& value) { SetUploadId(value); return *this;}
+    inline AbortMultipartUploadRequest& WithUploadId(Aws::String&& value) { SetUploadId(std::move(value)); return *this;}
+    inline AbortMultipartUploadRequest& WithUploadId(const char* value) { SetUploadId(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestPayer& GetRequestPayer() const{ return m_requestPayer; }
+    inline bool RequestPayerHasBeenSet() const { return m_requestPayerHasBeenSet; }
+    inline void SetRequestPayer(const RequestPayer& value) { m_requestPayerHasBeenSet = true; m_requestPayer = value; }
+    inline void SetRequestPayer(RequestPayer&& value) { m_requestPayerHasBeenSet = true; m_requestPayer = std::move(value); }
+    inline AbortMultipartUploadRequest& WithRequestPayer(const RequestPayer& value) { SetRequestPayer(value); return *this;}
+    inline AbortMultipartUploadRequest& WithRequestPayer(RequestPayer&& value) { SetRequestPayer(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline AbortMultipartUploadRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline AbortMultipartUploadRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline AbortMultipartUploadRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline AbortMultipartUploadRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline AbortMultipartUploadRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline AbortMultipartUploadRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_uploadId;
+    bool m_uploadIdHasBeenSet = false;
+
+    RequestPayer m_requestPayer;
+    bool m_requestPayerHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AbortMultipartUploadResult.h

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/RequestCharged.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class AbortMultipartUploadResult
+  {
+  public:
+    AWS_S3_API AbortMultipartUploadResult();
+    AWS_S3_API AbortMultipartUploadResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API AbortMultipartUploadResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    
+    inline const RequestCharged& GetRequestCharged() const{ return m_requestCharged; }
+    inline void SetRequestCharged(const RequestCharged& value) { m_requestCharged = value; }
+    inline void SetRequestCharged(RequestCharged&& value) { m_requestCharged = std::move(value); }
+    inline AbortMultipartUploadResult& WithRequestCharged(const RequestCharged& value) { SetRequestCharged(value); return *this;}
+    inline AbortMultipartUploadResult& WithRequestCharged(RequestCharged&& value) { SetRequestCharged(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline AbortMultipartUploadResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline AbortMultipartUploadResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline AbortMultipartUploadResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    RequestCharged m_requestCharged;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AccelerateConfiguration.h

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/BucketAccelerateStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Configures the transfer acceleration state for an Amazon S3 bucket. For more
+   * information, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html">Amazon
+   * S3 Transfer Acceleration</a> in the <i>Amazon S3 User Guide</i>.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AccelerateConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AccelerateConfiguration
+  {
+  public:
+    AWS_S3_API AccelerateConfiguration();
+    AWS_S3_API AccelerateConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AccelerateConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies the transfer acceleration status of the bucket.</p>
+     */
+    inline const BucketAccelerateStatus& GetStatus() const{ return m_status; }
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+    inline void SetStatus(const BucketAccelerateStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+    inline void SetStatus(BucketAccelerateStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+    inline AccelerateConfiguration& WithStatus(const BucketAccelerateStatus& value) { SetStatus(value); return *this;}
+    inline AccelerateConfiguration& WithStatus(BucketAccelerateStatus&& value) { SetStatus(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    BucketAccelerateStatus m_status;
+    bool m_statusHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AccessControlPolicy.h

@@ -0,0 +1,79 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/Owner.h>
+#include <aws/s3/model/Grant.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the elements that set the ACL permissions for an object per
+   * grantee.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AccessControlPolicy">AWS
+   * API Reference</a></p>
+   */
+  class AccessControlPolicy
+  {
+  public:
+    AWS_S3_API AccessControlPolicy();
+    AWS_S3_API AccessControlPolicy(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AccessControlPolicy& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>A list of grants.</p>
+     */
+    inline const Aws::Vector<Grant>& GetGrants() const{ return m_grants; }
+    inline bool GrantsHasBeenSet() const { return m_grantsHasBeenSet; }
+    inline void SetGrants(const Aws::Vector<Grant>& value) { m_grantsHasBeenSet = true; m_grants = value; }
+    inline void SetGrants(Aws::Vector<Grant>&& value) { m_grantsHasBeenSet = true; m_grants = std::move(value); }
+    inline AccessControlPolicy& WithGrants(const Aws::Vector<Grant>& value) { SetGrants(value); return *this;}
+    inline AccessControlPolicy& WithGrants(Aws::Vector<Grant>&& value) { SetGrants(std::move(value)); return *this;}
+    inline AccessControlPolicy& AddGrants(const Grant& value) { m_grantsHasBeenSet = true; m_grants.push_back(value); return *this; }
+    inline AccessControlPolicy& AddGrants(Grant&& value) { m_grantsHasBeenSet = true; m_grants.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>Container for the bucket owner's display name and ID.</p>
+     */
+    inline const Owner& GetOwner() const{ return m_owner; }
+    inline bool OwnerHasBeenSet() const { return m_ownerHasBeenSet; }
+    inline void SetOwner(const Owner& value) { m_ownerHasBeenSet = true; m_owner = value; }
+    inline void SetOwner(Owner&& value) { m_ownerHasBeenSet = true; m_owner = std::move(value); }
+    inline AccessControlPolicy& WithOwner(const Owner& value) { SetOwner(value); return *this;}
+    inline AccessControlPolicy& WithOwner(Owner&& value) { SetOwner(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::Vector<Grant> m_grants;
+    bool m_grantsHasBeenSet = false;
+
+    Owner m_owner;
+    bool m_ownerHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AccessControlTranslation.h

@@ -0,0 +1,62 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/OwnerOverride.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>A container for information about access control for replicas.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AccessControlTranslation">AWS
+   * API Reference</a></p>
+   */
+  class AccessControlTranslation
+  {
+  public:
+    AWS_S3_API AccessControlTranslation();
+    AWS_S3_API AccessControlTranslation(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AccessControlTranslation& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies the replica ownership. For default and valid values, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT
+     * bucket replication</a> in the <i>Amazon S3 API Reference</i>.</p>
+     */
+    inline const OwnerOverride& GetOwner() const{ return m_owner; }
+    inline bool OwnerHasBeenSet() const { return m_ownerHasBeenSet; }
+    inline void SetOwner(const OwnerOverride& value) { m_ownerHasBeenSet = true; m_owner = value; }
+    inline void SetOwner(OwnerOverride&& value) { m_ownerHasBeenSet = true; m_owner = std::move(value); }
+    inline AccessControlTranslation& WithOwner(const OwnerOverride& value) { SetOwner(value); return *this;}
+    inline AccessControlTranslation& WithOwner(OwnerOverride&& value) { SetOwner(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    OwnerOverride m_owner;
+    bool m_ownerHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AnalyticsAndOperator.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>A conjunction (logical AND) of predicates, which is used in evaluating a
+   * metrics filter. The operator must have at least two predicates in any
+   * combination, and an object must match all of the predicates for the filter to
+   * apply.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsAndOperator">AWS
+   * API Reference</a></p>
+   */
+  class AnalyticsAndOperator
+  {
+  public:
+    AWS_S3_API AnalyticsAndOperator();
+    AWS_S3_API AnalyticsAndOperator(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AnalyticsAndOperator& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The prefix to use when evaluating an AND predicate: The prefix that an object
+     * must have to be included in the metrics results.</p>
+     */
+    inline const Aws::String& GetPrefix() const{ return m_prefix; }
+    inline bool PrefixHasBeenSet() const { return m_prefixHasBeenSet; }
+    inline void SetPrefix(const Aws::String& value) { m_prefixHasBeenSet = true; m_prefix = value; }
+    inline void SetPrefix(Aws::String&& value) { m_prefixHasBeenSet = true; m_prefix = std::move(value); }
+    inline void SetPrefix(const char* value) { m_prefixHasBeenSet = true; m_prefix.assign(value); }
+    inline AnalyticsAndOperator& WithPrefix(const Aws::String& value) { SetPrefix(value); return *this;}
+    inline AnalyticsAndOperator& WithPrefix(Aws::String&& value) { SetPrefix(std::move(value)); return *this;}
+    inline AnalyticsAndOperator& WithPrefix(const char* value) { SetPrefix(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The list of tags to use when evaluating an AND predicate.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+    inline AnalyticsAndOperator& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+    inline AnalyticsAndOperator& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+    inline AnalyticsAndOperator& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+    inline AnalyticsAndOperator& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_prefix;
+    bool m_prefixHasBeenSet = false;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AnalyticsConfiguration.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/AnalyticsFilter.h>
+#include <aws/s3/model/StorageClassAnalysis.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies the configuration and any analyses for the analytics filter of an
+   * Amazon S3 bucket.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class AnalyticsConfiguration
+  {
+  public:
+    AWS_S3_API AnalyticsConfiguration();
+    AWS_S3_API AnalyticsConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AnalyticsConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The ID that identifies the analytics configuration.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+    inline AnalyticsConfiguration& WithId(const Aws::String& value) { SetId(value); return *this;}
+    inline AnalyticsConfiguration& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+    inline AnalyticsConfiguration& WithId(const char* value) { SetId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The filter used to describe a set of objects for analyses. A filter must have
+     * exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator). If no
+     * filter is provided, all objects will be considered in any analysis.</p>
+     */
+    inline const AnalyticsFilter& GetFilter() const{ return m_filter; }
+    inline bool FilterHasBeenSet() const { return m_filterHasBeenSet; }
+    inline void SetFilter(const AnalyticsFilter& value) { m_filterHasBeenSet = true; m_filter = value; }
+    inline void SetFilter(AnalyticsFilter&& value) { m_filterHasBeenSet = true; m_filter = std::move(value); }
+    inline AnalyticsConfiguration& WithFilter(const AnalyticsFilter& value) { SetFilter(value); return *this;}
+    inline AnalyticsConfiguration& WithFilter(AnalyticsFilter&& value) { SetFilter(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> Contains data related to access patterns to be collected and made available
+     * to analyze the tradeoffs between different storage classes. </p>
+     */
+    inline const StorageClassAnalysis& GetStorageClassAnalysis() const{ return m_storageClassAnalysis; }
+    inline bool StorageClassAnalysisHasBeenSet() const { return m_storageClassAnalysisHasBeenSet; }
+    inline void SetStorageClassAnalysis(const StorageClassAnalysis& value) { m_storageClassAnalysisHasBeenSet = true; m_storageClassAnalysis = value; }
+    inline void SetStorageClassAnalysis(StorageClassAnalysis&& value) { m_storageClassAnalysisHasBeenSet = true; m_storageClassAnalysis = std::move(value); }
+    inline AnalyticsConfiguration& WithStorageClassAnalysis(const StorageClassAnalysis& value) { SetStorageClassAnalysis(value); return *this;}
+    inline AnalyticsConfiguration& WithStorageClassAnalysis(StorageClassAnalysis&& value) { SetStorageClassAnalysis(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet = false;
+
+    AnalyticsFilter m_filter;
+    bool m_filterHasBeenSet = false;
+
+    StorageClassAnalysis m_storageClassAnalysis;
+    bool m_storageClassAnalysisHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AnalyticsExportDestination.h

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/AnalyticsS3BucketDestination.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Where to publish the analytics results.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsExportDestination">AWS
+   * API Reference</a></p>
+   */
+  class AnalyticsExportDestination
+  {
+  public:
+    AWS_S3_API AnalyticsExportDestination();
+    AWS_S3_API AnalyticsExportDestination(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AnalyticsExportDestination& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>A destination signifying output to an S3 bucket.</p>
+     */
+    inline const AnalyticsS3BucketDestination& GetS3BucketDestination() const{ return m_s3BucketDestination; }
+    inline bool S3BucketDestinationHasBeenSet() const { return m_s3BucketDestinationHasBeenSet; }
+    inline void SetS3BucketDestination(const AnalyticsS3BucketDestination& value) { m_s3BucketDestinationHasBeenSet = true; m_s3BucketDestination = value; }
+    inline void SetS3BucketDestination(AnalyticsS3BucketDestination&& value) { m_s3BucketDestinationHasBeenSet = true; m_s3BucketDestination = std::move(value); }
+    inline AnalyticsExportDestination& WithS3BucketDestination(const AnalyticsS3BucketDestination& value) { SetS3BucketDestination(value); return *this;}
+    inline AnalyticsExportDestination& WithS3BucketDestination(AnalyticsS3BucketDestination&& value) { SetS3BucketDestination(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    AnalyticsS3BucketDestination m_s3BucketDestination;
+    bool m_s3BucketDestinationHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AnalyticsFilter.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/Tag.h>
+#include <aws/s3/model/AnalyticsAndOperator.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>The filter used to describe a set of objects for analyses. A filter must have
+   * exactly one prefix, one tag, or one conjunction (AnalyticsAndOperator). If no
+   * filter is provided, all objects will be considered in any
+   * analysis.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsFilter">AWS
+   * API Reference</a></p>
+   */
+  class AnalyticsFilter
+  {
+  public:
+    AWS_S3_API AnalyticsFilter();
+    AWS_S3_API AnalyticsFilter(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AnalyticsFilter& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The prefix to use when evaluating an analytics filter.</p>
+     */
+    inline const Aws::String& GetPrefix() const{ return m_prefix; }
+    inline bool PrefixHasBeenSet() const { return m_prefixHasBeenSet; }
+    inline void SetPrefix(const Aws::String& value) { m_prefixHasBeenSet = true; m_prefix = value; }
+    inline void SetPrefix(Aws::String&& value) { m_prefixHasBeenSet = true; m_prefix = std::move(value); }
+    inline void SetPrefix(const char* value) { m_prefixHasBeenSet = true; m_prefix.assign(value); }
+    inline AnalyticsFilter& WithPrefix(const Aws::String& value) { SetPrefix(value); return *this;}
+    inline AnalyticsFilter& WithPrefix(Aws::String&& value) { SetPrefix(std::move(value)); return *this;}
+    inline AnalyticsFilter& WithPrefix(const char* value) { SetPrefix(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The tag to use when evaluating an analytics filter.</p>
+     */
+    inline const Tag& GetTag() const{ return m_tag; }
+    inline bool TagHasBeenSet() const { return m_tagHasBeenSet; }
+    inline void SetTag(const Tag& value) { m_tagHasBeenSet = true; m_tag = value; }
+    inline void SetTag(Tag&& value) { m_tagHasBeenSet = true; m_tag = std::move(value); }
+    inline AnalyticsFilter& WithTag(const Tag& value) { SetTag(value); return *this;}
+    inline AnalyticsFilter& WithTag(Tag&& value) { SetTag(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A conjunction (logical AND) of predicates, which is used in evaluating an
+     * analytics filter. The operator must have at least two predicates.</p>
+     */
+    inline const AnalyticsAndOperator& GetAnd() const{ return m_and; }
+    inline bool AndHasBeenSet() const { return m_andHasBeenSet; }
+    inline void SetAnd(const AnalyticsAndOperator& value) { m_andHasBeenSet = true; m_and = value; }
+    inline void SetAnd(AnalyticsAndOperator&& value) { m_andHasBeenSet = true; m_and = std::move(value); }
+    inline AnalyticsFilter& WithAnd(const AnalyticsAndOperator& value) { SetAnd(value); return *this;}
+    inline AnalyticsFilter& WithAnd(AnalyticsAndOperator&& value) { SetAnd(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_prefix;
+    bool m_prefixHasBeenSet = false;
+
+    Tag m_tag;
+    bool m_tagHasBeenSet = false;
+
+    AnalyticsAndOperator m_and;
+    bool m_andHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AnalyticsS3BucketDestination.h

@@ -0,0 +1,116 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/AnalyticsS3ExportFileFormat.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains information about where to publish the analytics
+   * results.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/AnalyticsS3BucketDestination">AWS
+   * API Reference</a></p>
+   */
+  class AnalyticsS3BucketDestination
+  {
+  public:
+    AWS_S3_API AnalyticsS3BucketDestination();
+    AWS_S3_API AnalyticsS3BucketDestination(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API AnalyticsS3BucketDestination& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies the file format used when exporting data to Amazon S3.</p>
+     */
+    inline const AnalyticsS3ExportFileFormat& GetFormat() const{ return m_format; }
+    inline bool FormatHasBeenSet() const { return m_formatHasBeenSet; }
+    inline void SetFormat(const AnalyticsS3ExportFileFormat& value) { m_formatHasBeenSet = true; m_format = value; }
+    inline void SetFormat(AnalyticsS3ExportFileFormat&& value) { m_formatHasBeenSet = true; m_format = std::move(value); }
+    inline AnalyticsS3BucketDestination& WithFormat(const AnalyticsS3ExportFileFormat& value) { SetFormat(value); return *this;}
+    inline AnalyticsS3BucketDestination& WithFormat(AnalyticsS3ExportFileFormat&& value) { SetFormat(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID that owns the destination S3 bucket. If no account ID is
+     * provided, the owner is not validated before exporting data.</p>  <p>
+     * Although this value is optional, we strongly recommend that you set it to help
+     * prevent problems if the destination bucket ownership changes. </p> 
+     */
+    inline const Aws::String& GetBucketAccountId() const{ return m_bucketAccountId; }
+    inline bool BucketAccountIdHasBeenSet() const { return m_bucketAccountIdHasBeenSet; }
+    inline void SetBucketAccountId(const Aws::String& value) { m_bucketAccountIdHasBeenSet = true; m_bucketAccountId = value; }
+    inline void SetBucketAccountId(Aws::String&& value) { m_bucketAccountIdHasBeenSet = true; m_bucketAccountId = std::move(value); }
+    inline void SetBucketAccountId(const char* value) { m_bucketAccountIdHasBeenSet = true; m_bucketAccountId.assign(value); }
+    inline AnalyticsS3BucketDestination& WithBucketAccountId(const Aws::String& value) { SetBucketAccountId(value); return *this;}
+    inline AnalyticsS3BucketDestination& WithBucketAccountId(Aws::String&& value) { SetBucketAccountId(std::move(value)); return *this;}
+    inline AnalyticsS3BucketDestination& WithBucketAccountId(const char* value) { SetBucketAccountId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) of the bucket to which data is exported.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline AnalyticsS3BucketDestination& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline AnalyticsS3BucketDestination& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline AnalyticsS3BucketDestination& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The prefix to use when exporting data. The prefix is prepended to all
+     * results.</p>
+     */
+    inline const Aws::String& GetPrefix() const{ return m_prefix; }
+    inline bool PrefixHasBeenSet() const { return m_prefixHasBeenSet; }
+    inline void SetPrefix(const Aws::String& value) { m_prefixHasBeenSet = true; m_prefix = value; }
+    inline void SetPrefix(Aws::String&& value) { m_prefixHasBeenSet = true; m_prefix = std::move(value); }
+    inline void SetPrefix(const char* value) { m_prefixHasBeenSet = true; m_prefix.assign(value); }
+    inline AnalyticsS3BucketDestination& WithPrefix(const Aws::String& value) { SetPrefix(value); return *this;}
+    inline AnalyticsS3BucketDestination& WithPrefix(Aws::String&& value) { SetPrefix(std::move(value)); return *this;}
+    inline AnalyticsS3BucketDestination& WithPrefix(const char* value) { SetPrefix(value); return *this;}
+    ///@}
+  private:
+
+    AnalyticsS3ExportFileFormat m_format;
+    bool m_formatHasBeenSet = false;
+
+    Aws::String m_bucketAccountId;
+    bool m_bucketAccountIdHasBeenSet = false;
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_prefix;
+    bool m_prefixHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/AnalyticsS3ExportFileFormat.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class AnalyticsS3ExportFileFormat
+  {
+    NOT_SET,
+    CSV
+  };
+
+namespace AnalyticsS3ExportFileFormatMapper
+{
+AWS_S3_API AnalyticsS3ExportFileFormat GetAnalyticsS3ExportFileFormatForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForAnalyticsS3ExportFileFormat(AnalyticsS3ExportFileFormat value);
+} // namespace AnalyticsS3ExportFileFormatMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/ArchiveStatus.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class ArchiveStatus
+  {
+    NOT_SET,
+    ARCHIVE_ACCESS,
+    DEEP_ARCHIVE_ACCESS
+  };
+
+namespace ArchiveStatusMapper
+{
+AWS_S3_API ArchiveStatus GetArchiveStatusForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForArchiveStatus(ArchiveStatus value);
+} // namespace ArchiveStatusMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Bucket.h

@@ -0,0 +1,98 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p> In terms of implementation, a Bucket is a resource. </p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Bucket">AWS API
+   * Reference</a></p>
+   */
+  class Bucket
+  {
+  public:
+    AWS_S3_API Bucket();
+    AWS_S3_API Bucket(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Bucket& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The name of the bucket.</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+    inline Bucket& WithName(const Aws::String& value) { SetName(value); return *this;}
+    inline Bucket& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+    inline Bucket& WithName(const char* value) { SetName(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Date the bucket was created. This date can change when making changes to your
+     * bucket, such as editing its bucket policy.</p>
+     */
+    inline const Aws::Utils::DateTime& GetCreationDate() const{ return m_creationDate; }
+    inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
+    inline void SetCreationDate(const Aws::Utils::DateTime& value) { m_creationDateHasBeenSet = true; m_creationDate = value; }
+    inline void SetCreationDate(Aws::Utils::DateTime&& value) { m_creationDateHasBeenSet = true; m_creationDate = std::move(value); }
+    inline Bucket& WithCreationDate(const Aws::Utils::DateTime& value) { SetCreationDate(value); return *this;}
+    inline Bucket& WithCreationDate(Aws::Utils::DateTime&& value) { SetCreationDate(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> <code>BucketRegion</code> indicates the Amazon Web Services region where the
+     * bucket is located. If the request contains at least one valid parameter, it is
+     * included in the response.</p>
+     */
+    inline const Aws::String& GetBucketRegion() const{ return m_bucketRegion; }
+    inline bool BucketRegionHasBeenSet() const { return m_bucketRegionHasBeenSet; }
+    inline void SetBucketRegion(const Aws::String& value) { m_bucketRegionHasBeenSet = true; m_bucketRegion = value; }
+    inline void SetBucketRegion(Aws::String&& value) { m_bucketRegionHasBeenSet = true; m_bucketRegion = std::move(value); }
+    inline void SetBucketRegion(const char* value) { m_bucketRegionHasBeenSet = true; m_bucketRegion.assign(value); }
+    inline Bucket& WithBucketRegion(const Aws::String& value) { SetBucketRegion(value); return *this;}
+    inline Bucket& WithBucketRegion(Aws::String&& value) { SetBucketRegion(std::move(value)); return *this;}
+    inline Bucket& WithBucketRegion(const char* value) { SetBucketRegion(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet = false;
+
+    Aws::Utils::DateTime m_creationDate;
+    bool m_creationDateHasBeenSet = false;
+
+    Aws::String m_bucketRegion;
+    bool m_bucketRegionHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketAccelerateStatus.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class BucketAccelerateStatus
+  {
+    NOT_SET,
+    Enabled,
+    Suspended
+  };
+
+namespace BucketAccelerateStatusMapper
+{
+AWS_S3_API BucketAccelerateStatus GetBucketAccelerateStatusForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForBucketAccelerateStatus(BucketAccelerateStatus value);
+} // namespace BucketAccelerateStatusMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketCannedACL.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class BucketCannedACL
+  {
+    NOT_SET,
+    private_,
+    public_read,
+    public_read_write,
+    authenticated_read
+  };
+
+namespace BucketCannedACLMapper
+{
+AWS_S3_API BucketCannedACL GetBucketCannedACLForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForBucketCannedACL(BucketCannedACL value);
+} // namespace BucketCannedACLMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketInfo.h

@@ -0,0 +1,80 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/DataRedundancy.h>
+#include <aws/s3/model/BucketType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies the information about the bucket that will be created. For more
+   * information about directory buckets, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html">Directory
+   * buckets</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>This functionality
+   * is only supported by directory buckets.</p> <p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/BucketInfo">AWS API
+   * Reference</a></p>
+   */
+  class BucketInfo
+  {
+  public:
+    AWS_S3_API BucketInfo();
+    AWS_S3_API BucketInfo(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API BucketInfo& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The number of Availability Zone that's used for redundancy for the
+     * bucket.</p>
+     */
+    inline const DataRedundancy& GetDataRedundancy() const{ return m_dataRedundancy; }
+    inline bool DataRedundancyHasBeenSet() const { return m_dataRedundancyHasBeenSet; }
+    inline void SetDataRedundancy(const DataRedundancy& value) { m_dataRedundancyHasBeenSet = true; m_dataRedundancy = value; }
+    inline void SetDataRedundancy(DataRedundancy&& value) { m_dataRedundancyHasBeenSet = true; m_dataRedundancy = std::move(value); }
+    inline BucketInfo& WithDataRedundancy(const DataRedundancy& value) { SetDataRedundancy(value); return *this;}
+    inline BucketInfo& WithDataRedundancy(DataRedundancy&& value) { SetDataRedundancy(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The type of bucket.</p>
+     */
+    inline const BucketType& GetType() const{ return m_type; }
+    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+    inline void SetType(const BucketType& value) { m_typeHasBeenSet = true; m_type = value; }
+    inline void SetType(BucketType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
+    inline BucketInfo& WithType(const BucketType& value) { SetType(value); return *this;}
+    inline BucketInfo& WithType(BucketType&& value) { SetType(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    DataRedundancy m_dataRedundancy;
+    bool m_dataRedundancyHasBeenSet = false;
+
+    BucketType m_type;
+    bool m_typeHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketLifecycleConfiguration.h

@@ -0,0 +1,66 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/LifecycleRule.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies the lifecycle configuration for objects in an Amazon S3 bucket. For
+   * more information, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html">Object
+   * Lifecycle Management</a> in the <i>Amazon S3 User Guide</i>.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/BucketLifecycleConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class BucketLifecycleConfiguration
+  {
+  public:
+    AWS_S3_API BucketLifecycleConfiguration();
+    AWS_S3_API BucketLifecycleConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API BucketLifecycleConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>A lifecycle rule for individual objects in an Amazon S3 bucket.</p>
+     */
+    inline const Aws::Vector<LifecycleRule>& GetRules() const{ return m_rules; }
+    inline bool RulesHasBeenSet() const { return m_rulesHasBeenSet; }
+    inline void SetRules(const Aws::Vector<LifecycleRule>& value) { m_rulesHasBeenSet = true; m_rules = value; }
+    inline void SetRules(Aws::Vector<LifecycleRule>&& value) { m_rulesHasBeenSet = true; m_rules = std::move(value); }
+    inline BucketLifecycleConfiguration& WithRules(const Aws::Vector<LifecycleRule>& value) { SetRules(value); return *this;}
+    inline BucketLifecycleConfiguration& WithRules(Aws::Vector<LifecycleRule>&& value) { SetRules(std::move(value)); return *this;}
+    inline BucketLifecycleConfiguration& AddRules(const LifecycleRule& value) { m_rulesHasBeenSet = true; m_rules.push_back(value); return *this; }
+    inline BucketLifecycleConfiguration& AddRules(LifecycleRule&& value) { m_rulesHasBeenSet = true; m_rules.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::Vector<LifecycleRule> m_rules;
+    bool m_rulesHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketLocationConstraint.h

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class BucketLocationConstraint
+  {
+    NOT_SET,
+    af_south_1,
+    ap_east_1,
+    ap_northeast_1,
+    ap_northeast_2,
+    ap_northeast_3,
+    ap_south_1,
+    ap_south_2,
+    ap_southeast_1,
+    ap_southeast_2,
+    ap_southeast_3,
+    ca_central_1,
+    cn_north_1,
+    cn_northwest_1,
+    EU,
+    eu_central_1,
+    eu_north_1,
+    eu_south_1,
+    eu_south_2,
+    eu_west_1,
+    eu_west_2,
+    eu_west_3,
+    me_south_1,
+    sa_east_1,
+    us_east_2,
+    us_gov_east_1,
+    us_gov_west_1,
+    us_west_1,
+    us_west_2,
+    us_iso_west_1,
+    us_east_1
+  };
+
+namespace BucketLocationConstraintMapper
+{
+AWS_S3_API BucketLocationConstraint GetBucketLocationConstraintForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForBucketLocationConstraint(BucketLocationConstraint value);
+} // namespace BucketLocationConstraintMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketLoggingStatus.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/LoggingEnabled.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for logging status information.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/BucketLoggingStatus">AWS
+   * API Reference</a></p>
+   */
+  class BucketLoggingStatus
+  {
+  public:
+    AWS_S3_API BucketLoggingStatus();
+    AWS_S3_API BucketLoggingStatus(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API BucketLoggingStatus& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    
+    inline const LoggingEnabled& GetLoggingEnabled() const{ return m_loggingEnabled; }
+    inline bool LoggingEnabledHasBeenSet() const { return m_loggingEnabledHasBeenSet; }
+    inline void SetLoggingEnabled(const LoggingEnabled& value) { m_loggingEnabledHasBeenSet = true; m_loggingEnabled = value; }
+    inline void SetLoggingEnabled(LoggingEnabled&& value) { m_loggingEnabledHasBeenSet = true; m_loggingEnabled = std::move(value); }
+    inline BucketLoggingStatus& WithLoggingEnabled(const LoggingEnabled& value) { SetLoggingEnabled(value); return *this;}
+    inline BucketLoggingStatus& WithLoggingEnabled(LoggingEnabled&& value) { SetLoggingEnabled(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    LoggingEnabled m_loggingEnabled;
+    bool m_loggingEnabledHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketLogsPermission.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class BucketLogsPermission
+  {
+    NOT_SET,
+    FULL_CONTROL,
+    READ,
+    WRITE
+  };
+
+namespace BucketLogsPermissionMapper
+{
+AWS_S3_API BucketLogsPermission GetBucketLogsPermissionForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForBucketLogsPermission(BucketLogsPermission value);
+} // namespace BucketLogsPermissionMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketType.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class BucketType
+  {
+    NOT_SET,
+    Directory
+  };
+
+namespace BucketTypeMapper
+{
+AWS_S3_API BucketType GetBucketTypeForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForBucketType(BucketType value);
+} // namespace BucketTypeMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/BucketVersioningStatus.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class BucketVersioningStatus
+  {
+    NOT_SET,
+    Enabled,
+    Suspended
+  };
+
+namespace BucketVersioningStatusMapper
+{
+AWS_S3_API BucketVersioningStatus GetBucketVersioningStatusForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForBucketVersioningStatus(BucketVersioningStatus value);
+} // namespace BucketVersioningStatusMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CORSConfiguration.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/CORSRule.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes the cross-origin access configuration for objects in an Amazon S3
+   * bucket. For more information, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html">Enabling
+   * Cross-Origin Resource Sharing</a> in the <i>Amazon S3 User
+   * Guide</i>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CORSConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class CORSConfiguration
+  {
+  public:
+    AWS_S3_API CORSConfiguration();
+    AWS_S3_API CORSConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CORSConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>A set of origins and methods (cross-origin access that you want to allow).
+     * You can add up to 100 rules to the configuration.</p>
+     */
+    inline const Aws::Vector<CORSRule>& GetCORSRules() const{ return m_cORSRules; }
+    inline bool CORSRulesHasBeenSet() const { return m_cORSRulesHasBeenSet; }
+    inline void SetCORSRules(const Aws::Vector<CORSRule>& value) { m_cORSRulesHasBeenSet = true; m_cORSRules = value; }
+    inline void SetCORSRules(Aws::Vector<CORSRule>&& value) { m_cORSRulesHasBeenSet = true; m_cORSRules = std::move(value); }
+    inline CORSConfiguration& WithCORSRules(const Aws::Vector<CORSRule>& value) { SetCORSRules(value); return *this;}
+    inline CORSConfiguration& WithCORSRules(Aws::Vector<CORSRule>&& value) { SetCORSRules(std::move(value)); return *this;}
+    inline CORSConfiguration& AddCORSRules(const CORSRule& value) { m_cORSRulesHasBeenSet = true; m_cORSRules.push_back(value); return *this; }
+    inline CORSConfiguration& AddCORSRules(CORSRule&& value) { m_cORSRulesHasBeenSet = true; m_cORSRules.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::Vector<CORSRule> m_cORSRules;
+    bool m_cORSRulesHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CORSRule.h

@@ -0,0 +1,158 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies a cross-origin access rule for an Amazon S3 bucket.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CORSRule">AWS API
+   * Reference</a></p>
+   */
+  class CORSRule
+  {
+  public:
+    AWS_S3_API CORSRule();
+    AWS_S3_API CORSRule(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CORSRule& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Unique identifier for the rule. The value cannot be longer than 255
+     * characters.</p>
+     */
+    inline const Aws::String& GetID() const{ return m_iD; }
+    inline bool IDHasBeenSet() const { return m_iDHasBeenSet; }
+    inline void SetID(const Aws::String& value) { m_iDHasBeenSet = true; m_iD = value; }
+    inline void SetID(Aws::String&& value) { m_iDHasBeenSet = true; m_iD = std::move(value); }
+    inline void SetID(const char* value) { m_iDHasBeenSet = true; m_iD.assign(value); }
+    inline CORSRule& WithID(const Aws::String& value) { SetID(value); return *this;}
+    inline CORSRule& WithID(Aws::String&& value) { SetID(std::move(value)); return *this;}
+    inline CORSRule& WithID(const char* value) { SetID(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Headers that are specified in the <code>Access-Control-Request-Headers</code>
+     * header. These headers are allowed in a preflight OPTIONS request. In response to
+     * any preflight OPTIONS request, Amazon S3 returns any requested headers that are
+     * allowed.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedHeaders() const{ return m_allowedHeaders; }
+    inline bool AllowedHeadersHasBeenSet() const { return m_allowedHeadersHasBeenSet; }
+    inline void SetAllowedHeaders(const Aws::Vector<Aws::String>& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders = value; }
+    inline void SetAllowedHeaders(Aws::Vector<Aws::String>&& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders = std::move(value); }
+    inline CORSRule& WithAllowedHeaders(const Aws::Vector<Aws::String>& value) { SetAllowedHeaders(value); return *this;}
+    inline CORSRule& WithAllowedHeaders(Aws::Vector<Aws::String>&& value) { SetAllowedHeaders(std::move(value)); return *this;}
+    inline CORSRule& AddAllowedHeaders(const Aws::String& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders.push_back(value); return *this; }
+    inline CORSRule& AddAllowedHeaders(Aws::String&& value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders.push_back(std::move(value)); return *this; }
+    inline CORSRule& AddAllowedHeaders(const char* value) { m_allowedHeadersHasBeenSet = true; m_allowedHeaders.push_back(value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>An HTTP method that you allow the origin to execute. Valid values are
+     * <code>GET</code>, <code>PUT</code>, <code>HEAD</code>, <code>POST</code>, and
+     * <code>DELETE</code>.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedMethods() const{ return m_allowedMethods; }
+    inline bool AllowedMethodsHasBeenSet() const { return m_allowedMethodsHasBeenSet; }
+    inline void SetAllowedMethods(const Aws::Vector<Aws::String>& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods = value; }
+    inline void SetAllowedMethods(Aws::Vector<Aws::String>&& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods = std::move(value); }
+    inline CORSRule& WithAllowedMethods(const Aws::Vector<Aws::String>& value) { SetAllowedMethods(value); return *this;}
+    inline CORSRule& WithAllowedMethods(Aws::Vector<Aws::String>&& value) { SetAllowedMethods(std::move(value)); return *this;}
+    inline CORSRule& AddAllowedMethods(const Aws::String& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods.push_back(value); return *this; }
+    inline CORSRule& AddAllowedMethods(Aws::String&& value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods.push_back(std::move(value)); return *this; }
+    inline CORSRule& AddAllowedMethods(const char* value) { m_allowedMethodsHasBeenSet = true; m_allowedMethods.push_back(value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>One or more origins you want customers to be able to access the bucket
+     * from.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetAllowedOrigins() const{ return m_allowedOrigins; }
+    inline bool AllowedOriginsHasBeenSet() const { return m_allowedOriginsHasBeenSet; }
+    inline void SetAllowedOrigins(const Aws::Vector<Aws::String>& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins = value; }
+    inline void SetAllowedOrigins(Aws::Vector<Aws::String>&& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins = std::move(value); }
+    inline CORSRule& WithAllowedOrigins(const Aws::Vector<Aws::String>& value) { SetAllowedOrigins(value); return *this;}
+    inline CORSRule& WithAllowedOrigins(Aws::Vector<Aws::String>&& value) { SetAllowedOrigins(std::move(value)); return *this;}
+    inline CORSRule& AddAllowedOrigins(const Aws::String& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins.push_back(value); return *this; }
+    inline CORSRule& AddAllowedOrigins(Aws::String&& value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins.push_back(std::move(value)); return *this; }
+    inline CORSRule& AddAllowedOrigins(const char* value) { m_allowedOriginsHasBeenSet = true; m_allowedOrigins.push_back(value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>One or more headers in the response that you want customers to be able to
+     * access from their applications (for example, from a JavaScript
+     * <code>XMLHttpRequest</code> object).</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetExposeHeaders() const{ return m_exposeHeaders; }
+    inline bool ExposeHeadersHasBeenSet() const { return m_exposeHeadersHasBeenSet; }
+    inline void SetExposeHeaders(const Aws::Vector<Aws::String>& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders = value; }
+    inline void SetExposeHeaders(Aws::Vector<Aws::String>&& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders = std::move(value); }
+    inline CORSRule& WithExposeHeaders(const Aws::Vector<Aws::String>& value) { SetExposeHeaders(value); return *this;}
+    inline CORSRule& WithExposeHeaders(Aws::Vector<Aws::String>&& value) { SetExposeHeaders(std::move(value)); return *this;}
+    inline CORSRule& AddExposeHeaders(const Aws::String& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders.push_back(value); return *this; }
+    inline CORSRule& AddExposeHeaders(Aws::String&& value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders.push_back(std::move(value)); return *this; }
+    inline CORSRule& AddExposeHeaders(const char* value) { m_exposeHeadersHasBeenSet = true; m_exposeHeaders.push_back(value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>The time in seconds that your browser is to cache the preflight response for
+     * the specified resource.</p>
+     */
+    inline int GetMaxAgeSeconds() const{ return m_maxAgeSeconds; }
+    inline bool MaxAgeSecondsHasBeenSet() const { return m_maxAgeSecondsHasBeenSet; }
+    inline void SetMaxAgeSeconds(int value) { m_maxAgeSecondsHasBeenSet = true; m_maxAgeSeconds = value; }
+    inline CORSRule& WithMaxAgeSeconds(int value) { SetMaxAgeSeconds(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_iD;
+    bool m_iDHasBeenSet = false;
+
+    Aws::Vector<Aws::String> m_allowedHeaders;
+    bool m_allowedHeadersHasBeenSet = false;
+
+    Aws::Vector<Aws::String> m_allowedMethods;
+    bool m_allowedMethodsHasBeenSet = false;
+
+    Aws::Vector<Aws::String> m_allowedOrigins;
+    bool m_allowedOriginsHasBeenSet = false;
+
+    Aws::Vector<Aws::String> m_exposeHeaders;
+    bool m_exposeHeadersHasBeenSet = false;
+
+    int m_maxAgeSeconds;
+    bool m_maxAgeSecondsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CSVInput.h

@@ -0,0 +1,178 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/FileHeaderInfo.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes how an uncompressed comma-separated values (CSV)-formatted input
+   * object is formatted.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CSVInput">AWS API
+   * Reference</a></p>
+   */
+  class CSVInput
+  {
+  public:
+    AWS_S3_API CSVInput();
+    AWS_S3_API CSVInput(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CSVInput& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Describes the first line of input. Valid values are:</p> <ul> <li> <p>
+     * <code>NONE</code>: First line is not a header.</p> </li> <li> <p>
+     * <code>IGNORE</code>: First line is a header, but you can't use the header values
+     * to indicate the column in an expression. You can use column position (such as
+     * _1, _2, …) to indicate the column (<code>SELECT s._1 FROM OBJECT s</code>).</p>
+     * </li> <li> <p> <code>Use</code>: First line is a header, and you can use the
+     * header value to identify a column in an expression (<code>SELECT "name" FROM
+     * OBJECT</code>). </p> </li> </ul>
+     */
+    inline const FileHeaderInfo& GetFileHeaderInfo() const{ return m_fileHeaderInfo; }
+    inline bool FileHeaderInfoHasBeenSet() const { return m_fileHeaderInfoHasBeenSet; }
+    inline void SetFileHeaderInfo(const FileHeaderInfo& value) { m_fileHeaderInfoHasBeenSet = true; m_fileHeaderInfo = value; }
+    inline void SetFileHeaderInfo(FileHeaderInfo&& value) { m_fileHeaderInfoHasBeenSet = true; m_fileHeaderInfo = std::move(value); }
+    inline CSVInput& WithFileHeaderInfo(const FileHeaderInfo& value) { SetFileHeaderInfo(value); return *this;}
+    inline CSVInput& WithFileHeaderInfo(FileHeaderInfo&& value) { SetFileHeaderInfo(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used to indicate that a row should be ignored when the
+     * character is present at the start of that row. You can specify any character to
+     * indicate a comment line. The default character is <code>#</code>.</p>
+     * <p>Default: <code>#</code> </p>
+     */
+    inline const Aws::String& GetComments() const{ return m_comments; }
+    inline bool CommentsHasBeenSet() const { return m_commentsHasBeenSet; }
+    inline void SetComments(const Aws::String& value) { m_commentsHasBeenSet = true; m_comments = value; }
+    inline void SetComments(Aws::String&& value) { m_commentsHasBeenSet = true; m_comments = std::move(value); }
+    inline void SetComments(const char* value) { m_commentsHasBeenSet = true; m_comments.assign(value); }
+    inline CSVInput& WithComments(const Aws::String& value) { SetComments(value); return *this;}
+    inline CSVInput& WithComments(Aws::String&& value) { SetComments(std::move(value)); return *this;}
+    inline CSVInput& WithComments(const char* value) { SetComments(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used for escaping the quotation mark character inside an
+     * already escaped value. For example, the value <code>""" a , b """</code> is
+     * parsed as <code>" a , b "</code>.</p>
+     */
+    inline const Aws::String& GetQuoteEscapeCharacter() const{ return m_quoteEscapeCharacter; }
+    inline bool QuoteEscapeCharacterHasBeenSet() const { return m_quoteEscapeCharacterHasBeenSet; }
+    inline void SetQuoteEscapeCharacter(const Aws::String& value) { m_quoteEscapeCharacterHasBeenSet = true; m_quoteEscapeCharacter = value; }
+    inline void SetQuoteEscapeCharacter(Aws::String&& value) { m_quoteEscapeCharacterHasBeenSet = true; m_quoteEscapeCharacter = std::move(value); }
+    inline void SetQuoteEscapeCharacter(const char* value) { m_quoteEscapeCharacterHasBeenSet = true; m_quoteEscapeCharacter.assign(value); }
+    inline CSVInput& WithQuoteEscapeCharacter(const Aws::String& value) { SetQuoteEscapeCharacter(value); return *this;}
+    inline CSVInput& WithQuoteEscapeCharacter(Aws::String&& value) { SetQuoteEscapeCharacter(std::move(value)); return *this;}
+    inline CSVInput& WithQuoteEscapeCharacter(const char* value) { SetQuoteEscapeCharacter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used to separate individual records in the input. Instead
+     * of the default value, you can specify an arbitrary delimiter.</p>
+     */
+    inline const Aws::String& GetRecordDelimiter() const{ return m_recordDelimiter; }
+    inline bool RecordDelimiterHasBeenSet() const { return m_recordDelimiterHasBeenSet; }
+    inline void SetRecordDelimiter(const Aws::String& value) { m_recordDelimiterHasBeenSet = true; m_recordDelimiter = value; }
+    inline void SetRecordDelimiter(Aws::String&& value) { m_recordDelimiterHasBeenSet = true; m_recordDelimiter = std::move(value); }
+    inline void SetRecordDelimiter(const char* value) { m_recordDelimiterHasBeenSet = true; m_recordDelimiter.assign(value); }
+    inline CSVInput& WithRecordDelimiter(const Aws::String& value) { SetRecordDelimiter(value); return *this;}
+    inline CSVInput& WithRecordDelimiter(Aws::String&& value) { SetRecordDelimiter(std::move(value)); return *this;}
+    inline CSVInput& WithRecordDelimiter(const char* value) { SetRecordDelimiter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used to separate individual fields in a record. You can
+     * specify an arbitrary delimiter.</p>
+     */
+    inline const Aws::String& GetFieldDelimiter() const{ return m_fieldDelimiter; }
+    inline bool FieldDelimiterHasBeenSet() const { return m_fieldDelimiterHasBeenSet; }
+    inline void SetFieldDelimiter(const Aws::String& value) { m_fieldDelimiterHasBeenSet = true; m_fieldDelimiter = value; }
+    inline void SetFieldDelimiter(Aws::String&& value) { m_fieldDelimiterHasBeenSet = true; m_fieldDelimiter = std::move(value); }
+    inline void SetFieldDelimiter(const char* value) { m_fieldDelimiterHasBeenSet = true; m_fieldDelimiter.assign(value); }
+    inline CSVInput& WithFieldDelimiter(const Aws::String& value) { SetFieldDelimiter(value); return *this;}
+    inline CSVInput& WithFieldDelimiter(Aws::String&& value) { SetFieldDelimiter(std::move(value)); return *this;}
+    inline CSVInput& WithFieldDelimiter(const char* value) { SetFieldDelimiter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used for escaping when the field delimiter is part of the
+     * value. For example, if the value is <code>a, b</code>, Amazon S3 wraps this
+     * field value in quotation marks, as follows: <code>" a , b "</code>.</p> <p>Type:
+     * String</p> <p>Default: <code>"</code> </p> <p>Ancestors: <code>CSV</code> </p>
+     */
+    inline const Aws::String& GetQuoteCharacter() const{ return m_quoteCharacter; }
+    inline bool QuoteCharacterHasBeenSet() const { return m_quoteCharacterHasBeenSet; }
+    inline void SetQuoteCharacter(const Aws::String& value) { m_quoteCharacterHasBeenSet = true; m_quoteCharacter = value; }
+    inline void SetQuoteCharacter(Aws::String&& value) { m_quoteCharacterHasBeenSet = true; m_quoteCharacter = std::move(value); }
+    inline void SetQuoteCharacter(const char* value) { m_quoteCharacterHasBeenSet = true; m_quoteCharacter.assign(value); }
+    inline CSVInput& WithQuoteCharacter(const Aws::String& value) { SetQuoteCharacter(value); return *this;}
+    inline CSVInput& WithQuoteCharacter(Aws::String&& value) { SetQuoteCharacter(std::move(value)); return *this;}
+    inline CSVInput& WithQuoteCharacter(const char* value) { SetQuoteCharacter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies that CSV field values may contain quoted record delimiters and such
+     * records should be allowed. Default value is FALSE. Setting this value to TRUE
+     * may lower performance.</p>
+     */
+    inline bool GetAllowQuotedRecordDelimiter() const{ return m_allowQuotedRecordDelimiter; }
+    inline bool AllowQuotedRecordDelimiterHasBeenSet() const { return m_allowQuotedRecordDelimiterHasBeenSet; }
+    inline void SetAllowQuotedRecordDelimiter(bool value) { m_allowQuotedRecordDelimiterHasBeenSet = true; m_allowQuotedRecordDelimiter = value; }
+    inline CSVInput& WithAllowQuotedRecordDelimiter(bool value) { SetAllowQuotedRecordDelimiter(value); return *this;}
+    ///@}
+  private:
+
+    FileHeaderInfo m_fileHeaderInfo;
+    bool m_fileHeaderInfoHasBeenSet = false;
+
+    Aws::String m_comments;
+    bool m_commentsHasBeenSet = false;
+
+    Aws::String m_quoteEscapeCharacter;
+    bool m_quoteEscapeCharacterHasBeenSet = false;
+
+    Aws::String m_recordDelimiter;
+    bool m_recordDelimiterHasBeenSet = false;
+
+    Aws::String m_fieldDelimiter;
+    bool m_fieldDelimiterHasBeenSet = false;
+
+    Aws::String m_quoteCharacter;
+    bool m_quoteCharacterHasBeenSet = false;
+
+    bool m_allowQuotedRecordDelimiter;
+    bool m_allowQuotedRecordDelimiterHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CSVOutput.h

@@ -0,0 +1,137 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/QuoteFields.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Describes how uncompressed comma-separated values (CSV)-formatted results are
+   * formatted.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CSVOutput">AWS API
+   * Reference</a></p>
+   */
+  class CSVOutput
+  {
+  public:
+    AWS_S3_API CSVOutput();
+    AWS_S3_API CSVOutput(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CSVOutput& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Indicates whether to use quotation marks around output fields. </p> <ul> <li>
+     * <p> <code>ALWAYS</code>: Always use quotation marks for output fields.</p> </li>
+     * <li> <p> <code>ASNEEDED</code>: Use quotation marks for output fields when
+     * needed.</p> </li> </ul>
+     */
+    inline const QuoteFields& GetQuoteFields() const{ return m_quoteFields; }
+    inline bool QuoteFieldsHasBeenSet() const { return m_quoteFieldsHasBeenSet; }
+    inline void SetQuoteFields(const QuoteFields& value) { m_quoteFieldsHasBeenSet = true; m_quoteFields = value; }
+    inline void SetQuoteFields(QuoteFields&& value) { m_quoteFieldsHasBeenSet = true; m_quoteFields = std::move(value); }
+    inline CSVOutput& WithQuoteFields(const QuoteFields& value) { SetQuoteFields(value); return *this;}
+    inline CSVOutput& WithQuoteFields(QuoteFields&& value) { SetQuoteFields(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The single character used for escaping the quote character inside an already
+     * escaped value.</p>
+     */
+    inline const Aws::String& GetQuoteEscapeCharacter() const{ return m_quoteEscapeCharacter; }
+    inline bool QuoteEscapeCharacterHasBeenSet() const { return m_quoteEscapeCharacterHasBeenSet; }
+    inline void SetQuoteEscapeCharacter(const Aws::String& value) { m_quoteEscapeCharacterHasBeenSet = true; m_quoteEscapeCharacter = value; }
+    inline void SetQuoteEscapeCharacter(Aws::String&& value) { m_quoteEscapeCharacterHasBeenSet = true; m_quoteEscapeCharacter = std::move(value); }
+    inline void SetQuoteEscapeCharacter(const char* value) { m_quoteEscapeCharacterHasBeenSet = true; m_quoteEscapeCharacter.assign(value); }
+    inline CSVOutput& WithQuoteEscapeCharacter(const Aws::String& value) { SetQuoteEscapeCharacter(value); return *this;}
+    inline CSVOutput& WithQuoteEscapeCharacter(Aws::String&& value) { SetQuoteEscapeCharacter(std::move(value)); return *this;}
+    inline CSVOutput& WithQuoteEscapeCharacter(const char* value) { SetQuoteEscapeCharacter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used to separate individual records in the output. Instead
+     * of the default value, you can specify an arbitrary delimiter.</p>
+     */
+    inline const Aws::String& GetRecordDelimiter() const{ return m_recordDelimiter; }
+    inline bool RecordDelimiterHasBeenSet() const { return m_recordDelimiterHasBeenSet; }
+    inline void SetRecordDelimiter(const Aws::String& value) { m_recordDelimiterHasBeenSet = true; m_recordDelimiter = value; }
+    inline void SetRecordDelimiter(Aws::String&& value) { m_recordDelimiterHasBeenSet = true; m_recordDelimiter = std::move(value); }
+    inline void SetRecordDelimiter(const char* value) { m_recordDelimiterHasBeenSet = true; m_recordDelimiter.assign(value); }
+    inline CSVOutput& WithRecordDelimiter(const Aws::String& value) { SetRecordDelimiter(value); return *this;}
+    inline CSVOutput& WithRecordDelimiter(Aws::String&& value) { SetRecordDelimiter(std::move(value)); return *this;}
+    inline CSVOutput& WithRecordDelimiter(const char* value) { SetRecordDelimiter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value used to separate individual fields in a record. You can specify an
+     * arbitrary delimiter.</p>
+     */
+    inline const Aws::String& GetFieldDelimiter() const{ return m_fieldDelimiter; }
+    inline bool FieldDelimiterHasBeenSet() const { return m_fieldDelimiterHasBeenSet; }
+    inline void SetFieldDelimiter(const Aws::String& value) { m_fieldDelimiterHasBeenSet = true; m_fieldDelimiter = value; }
+    inline void SetFieldDelimiter(Aws::String&& value) { m_fieldDelimiterHasBeenSet = true; m_fieldDelimiter = std::move(value); }
+    inline void SetFieldDelimiter(const char* value) { m_fieldDelimiterHasBeenSet = true; m_fieldDelimiter.assign(value); }
+    inline CSVOutput& WithFieldDelimiter(const Aws::String& value) { SetFieldDelimiter(value); return *this;}
+    inline CSVOutput& WithFieldDelimiter(Aws::String&& value) { SetFieldDelimiter(std::move(value)); return *this;}
+    inline CSVOutput& WithFieldDelimiter(const char* value) { SetFieldDelimiter(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A single character used for escaping when the field delimiter is part of the
+     * value. For example, if the value is <code>a, b</code>, Amazon S3 wraps this
+     * field value in quotation marks, as follows: <code>" a , b "</code>.</p>
+     */
+    inline const Aws::String& GetQuoteCharacter() const{ return m_quoteCharacter; }
+    inline bool QuoteCharacterHasBeenSet() const { return m_quoteCharacterHasBeenSet; }
+    inline void SetQuoteCharacter(const Aws::String& value) { m_quoteCharacterHasBeenSet = true; m_quoteCharacter = value; }
+    inline void SetQuoteCharacter(Aws::String&& value) { m_quoteCharacterHasBeenSet = true; m_quoteCharacter = std::move(value); }
+    inline void SetQuoteCharacter(const char* value) { m_quoteCharacterHasBeenSet = true; m_quoteCharacter.assign(value); }
+    inline CSVOutput& WithQuoteCharacter(const Aws::String& value) { SetQuoteCharacter(value); return *this;}
+    inline CSVOutput& WithQuoteCharacter(Aws::String&& value) { SetQuoteCharacter(std::move(value)); return *this;}
+    inline CSVOutput& WithQuoteCharacter(const char* value) { SetQuoteCharacter(value); return *this;}
+    ///@}
+  private:
+
+    QuoteFields m_quoteFields;
+    bool m_quoteFieldsHasBeenSet = false;
+
+    Aws::String m_quoteEscapeCharacter;
+    bool m_quoteEscapeCharacterHasBeenSet = false;
+
+    Aws::String m_recordDelimiter;
+    bool m_recordDelimiterHasBeenSet = false;
+
+    Aws::String m_fieldDelimiter;
+    bool m_fieldDelimiterHasBeenSet = false;
+
+    Aws::String m_quoteCharacter;
+    bool m_quoteCharacterHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Checksum.h

@@ -0,0 +1,141 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains all the possible checksum or digest values for an
+   * object.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Checksum">AWS API
+   * Reference</a></p>
+   */
+  class Checksum
+  {
+  public:
+    AWS_S3_API Checksum();
+    AWS_S3_API Checksum(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Checksum& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32 checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32() const{ return m_checksumCRC32; }
+    inline bool ChecksumCRC32HasBeenSet() const { return m_checksumCRC32HasBeenSet; }
+    inline void SetChecksumCRC32(const Aws::String& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = value; }
+    inline void SetChecksumCRC32(Aws::String&& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = std::move(value); }
+    inline void SetChecksumCRC32(const char* value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32.assign(value); }
+    inline Checksum& WithChecksumCRC32(const Aws::String& value) { SetChecksumCRC32(value); return *this;}
+    inline Checksum& WithChecksumCRC32(Aws::String&& value) { SetChecksumCRC32(std::move(value)); return *this;}
+    inline Checksum& WithChecksumCRC32(const char* value) { SetChecksumCRC32(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32C checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32C() const{ return m_checksumCRC32C; }
+    inline bool ChecksumCRC32CHasBeenSet() const { return m_checksumCRC32CHasBeenSet; }
+    inline void SetChecksumCRC32C(const Aws::String& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = value; }
+    inline void SetChecksumCRC32C(Aws::String&& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = std::move(value); }
+    inline void SetChecksumCRC32C(const char* value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C.assign(value); }
+    inline Checksum& WithChecksumCRC32C(const Aws::String& value) { SetChecksumCRC32C(value); return *this;}
+    inline Checksum& WithChecksumCRC32C(Aws::String&& value) { SetChecksumCRC32C(std::move(value)); return *this;}
+    inline Checksum& WithChecksumCRC32C(const char* value) { SetChecksumCRC32C(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 160-bit SHA-1 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use the API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA1() const{ return m_checksumSHA1; }
+    inline bool ChecksumSHA1HasBeenSet() const { return m_checksumSHA1HasBeenSet; }
+    inline void SetChecksumSHA1(const Aws::String& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = value; }
+    inline void SetChecksumSHA1(Aws::String&& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = std::move(value); }
+    inline void SetChecksumSHA1(const char* value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1.assign(value); }
+    inline Checksum& WithChecksumSHA1(const Aws::String& value) { SetChecksumSHA1(value); return *this;}
+    inline Checksum& WithChecksumSHA1(Aws::String&& value) { SetChecksumSHA1(std::move(value)); return *this;}
+    inline Checksum& WithChecksumSHA1(const char* value) { SetChecksumSHA1(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 256-bit SHA-256 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA256() const{ return m_checksumSHA256; }
+    inline bool ChecksumSHA256HasBeenSet() const { return m_checksumSHA256HasBeenSet; }
+    inline void SetChecksumSHA256(const Aws::String& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = value; }
+    inline void SetChecksumSHA256(Aws::String&& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = std::move(value); }
+    inline void SetChecksumSHA256(const char* value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256.assign(value); }
+    inline Checksum& WithChecksumSHA256(const Aws::String& value) { SetChecksumSHA256(value); return *this;}
+    inline Checksum& WithChecksumSHA256(Aws::String&& value) { SetChecksumSHA256(std::move(value)); return *this;}
+    inline Checksum& WithChecksumSHA256(const char* value) { SetChecksumSHA256(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_checksumCRC32;
+    bool m_checksumCRC32HasBeenSet = false;
+
+    Aws::String m_checksumCRC32C;
+    bool m_checksumCRC32CHasBeenSet = false;
+
+    Aws::String m_checksumSHA1;
+    bool m_checksumSHA1HasBeenSet = false;
+
+    Aws::String m_checksumSHA256;
+    bool m_checksumSHA256HasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/ChecksumAlgorithm.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class ChecksumAlgorithm
+  {
+    NOT_SET,
+    CRC32,
+    CRC32C,
+    SHA1,
+    SHA256
+  };
+
+namespace ChecksumAlgorithmMapper
+{
+AWS_S3_API ChecksumAlgorithm GetChecksumAlgorithmForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForChecksumAlgorithm(ChecksumAlgorithm value);
+} // namespace ChecksumAlgorithmMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/ChecksumMode.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class ChecksumMode
+  {
+    NOT_SET,
+    ENABLED
+  };
+
+namespace ChecksumModeMapper
+{
+AWS_S3_API ChecksumMode GetChecksumModeForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForChecksumMode(ChecksumMode value);
+} // namespace ChecksumModeMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CloudFunctionConfiguration.h

@@ -0,0 +1,114 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/Event.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for specifying the Lambda notification configuration.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CloudFunctionConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class CloudFunctionConfiguration
+  {
+  public:
+    AWS_S3_API CloudFunctionConfiguration();
+    AWS_S3_API CloudFunctionConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CloudFunctionConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    
+    inline const Aws::String& GetId() const{ return m_id; }
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+    inline CloudFunctionConfiguration& WithId(const Aws::String& value) { SetId(value); return *this;}
+    inline CloudFunctionConfiguration& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+    inline CloudFunctionConfiguration& WithId(const char* value) { SetId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Bucket events for which to send notifications.</p>
+     */
+    inline const Aws::Vector<Event>& GetEvents() const{ return m_events; }
+    inline bool EventsHasBeenSet() const { return m_eventsHasBeenSet; }
+    inline void SetEvents(const Aws::Vector<Event>& value) { m_eventsHasBeenSet = true; m_events = value; }
+    inline void SetEvents(Aws::Vector<Event>&& value) { m_eventsHasBeenSet = true; m_events = std::move(value); }
+    inline CloudFunctionConfiguration& WithEvents(const Aws::Vector<Event>& value) { SetEvents(value); return *this;}
+    inline CloudFunctionConfiguration& WithEvents(Aws::Vector<Event>&& value) { SetEvents(std::move(value)); return *this;}
+    inline CloudFunctionConfiguration& AddEvents(const Event& value) { m_eventsHasBeenSet = true; m_events.push_back(value); return *this; }
+    inline CloudFunctionConfiguration& AddEvents(Event&& value) { m_eventsHasBeenSet = true; m_events.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>Lambda cloud function ARN that Amazon S3 can invoke when it detects events of
+     * the specified type.</p>
+     */
+    inline const Aws::String& GetCloudFunction() const{ return m_cloudFunction; }
+    inline bool CloudFunctionHasBeenSet() const { return m_cloudFunctionHasBeenSet; }
+    inline void SetCloudFunction(const Aws::String& value) { m_cloudFunctionHasBeenSet = true; m_cloudFunction = value; }
+    inline void SetCloudFunction(Aws::String&& value) { m_cloudFunctionHasBeenSet = true; m_cloudFunction = std::move(value); }
+    inline void SetCloudFunction(const char* value) { m_cloudFunctionHasBeenSet = true; m_cloudFunction.assign(value); }
+    inline CloudFunctionConfiguration& WithCloudFunction(const Aws::String& value) { SetCloudFunction(value); return *this;}
+    inline CloudFunctionConfiguration& WithCloudFunction(Aws::String&& value) { SetCloudFunction(std::move(value)); return *this;}
+    inline CloudFunctionConfiguration& WithCloudFunction(const char* value) { SetCloudFunction(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The role supporting the invocation of the Lambda function</p>
+     */
+    inline const Aws::String& GetInvocationRole() const{ return m_invocationRole; }
+    inline bool InvocationRoleHasBeenSet() const { return m_invocationRoleHasBeenSet; }
+    inline void SetInvocationRole(const Aws::String& value) { m_invocationRoleHasBeenSet = true; m_invocationRole = value; }
+    inline void SetInvocationRole(Aws::String&& value) { m_invocationRoleHasBeenSet = true; m_invocationRole = std::move(value); }
+    inline void SetInvocationRole(const char* value) { m_invocationRoleHasBeenSet = true; m_invocationRole.assign(value); }
+    inline CloudFunctionConfiguration& WithInvocationRole(const Aws::String& value) { SetInvocationRole(value); return *this;}
+    inline CloudFunctionConfiguration& WithInvocationRole(Aws::String&& value) { SetInvocationRole(std::move(value)); return *this;}
+    inline CloudFunctionConfiguration& WithInvocationRole(const char* value) { SetInvocationRole(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_id;
+    bool m_idHasBeenSet = false;
+
+    Aws::Vector<Event> m_events;
+    bool m_eventsHasBeenSet = false;
+
+    Aws::String m_cloudFunction;
+    bool m_cloudFunctionHasBeenSet = false;
+
+    Aws::String m_invocationRole;
+    bool m_invocationRoleHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CommonPrefix.h

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for all (if there are any) keys between Prefix and the next
+   * occurrence of the string specified by a delimiter. CommonPrefixes lists keys
+   * that act like subdirectories in the directory specified by Prefix. For example,
+   * if the prefix is notes/ and the delimiter is a slash (/) as in
+   * notes/summer/july, the common prefix is notes/summer/. </p><p><h3>See Also:</h3>
+   * <a href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CommonPrefix">AWS
+   * API Reference</a></p>
+   */
+  class CommonPrefix
+  {
+  public:
+    AWS_S3_API CommonPrefix();
+    AWS_S3_API CommonPrefix(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CommonPrefix& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Container for the specified common prefix.</p>
+     */
+    inline const Aws::String& GetPrefix() const{ return m_prefix; }
+    inline bool PrefixHasBeenSet() const { return m_prefixHasBeenSet; }
+    inline void SetPrefix(const Aws::String& value) { m_prefixHasBeenSet = true; m_prefix = value; }
+    inline void SetPrefix(Aws::String&& value) { m_prefixHasBeenSet = true; m_prefix = std::move(value); }
+    inline void SetPrefix(const char* value) { m_prefixHasBeenSet = true; m_prefix.assign(value); }
+    inline CommonPrefix& WithPrefix(const Aws::String& value) { SetPrefix(value); return *this;}
+    inline CommonPrefix& WithPrefix(Aws::String&& value) { SetPrefix(std::move(value)); return *this;}
+    inline CommonPrefix& WithPrefix(const char* value) { SetPrefix(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_prefix;
+    bool m_prefixHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CompleteMultipartUploadRequest.h

@@ -0,0 +1,383 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/CompletedMultipartUpload.h>
+#include <aws/s3/model/RequestPayer.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class CompleteMultipartUploadRequest : public S3Request
+  {
+  public:
+    AWS_S3_API CompleteMultipartUploadRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CompleteMultipartUpload"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>Name of the bucket to which the multipart upload was initiated.</p> <p>
+     * <b>Directory buckets</b> - When you use this operation with a directory bucket,
+     * you must use virtual-hosted-style requests in the format <code>
+     * <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>.
+     * Path-style requests are not supported. Directory bucket names must be unique in
+     * the chosen Availability Zone. Bucket names must follow the format <code>
+     * <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>
+     * <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about
+     * bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Access
+     * points</b> - When you use this action with an access point, you must provide the
+     * alias of the access point in place of the bucket name or specify the access
+     * point ARN. When using the access point ARN, you must direct requests to the
+     * access point hostname. The access point hostname takes the form
+     * <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com.
+     * When using this action with an access point through the Amazon Web Services
+     * SDKs, you provide the access point ARN in place of the bucket name. For more
+     * information about access point ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using
+     * access points</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>Access
+     * points and Object Lambda access points are not supported by directory
+     * buckets.</p>  <p> <b>S3 on Outposts</b> - When you use this action with
+     * Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname.
+     * The S3 on Outposts hostname takes the form <code>
+     * <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>.
+     * When you use this action with S3 on Outposts through the Amazon Web Services
+     * SDKs, you provide the Outposts access point ARN in place of the bucket name. For
+     * more information about S3 on Outposts ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What
+     * is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline CompleteMultipartUploadRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Object key for which the multipart upload was initiated.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline CompleteMultipartUploadRequest& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The container for the multipart upload request information.</p>
+     */
+    inline const CompletedMultipartUpload& GetMultipartUpload() const{ return m_multipartUpload; }
+    inline bool MultipartUploadHasBeenSet() const { return m_multipartUploadHasBeenSet; }
+    inline void SetMultipartUpload(const CompletedMultipartUpload& value) { m_multipartUploadHasBeenSet = true; m_multipartUpload = value; }
+    inline void SetMultipartUpload(CompletedMultipartUpload&& value) { m_multipartUploadHasBeenSet = true; m_multipartUpload = std::move(value); }
+    inline CompleteMultipartUploadRequest& WithMultipartUpload(const CompletedMultipartUpload& value) { SetMultipartUpload(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithMultipartUpload(CompletedMultipartUpload&& value) { SetMultipartUpload(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>ID for the initiated multipart upload.</p>
+     */
+    inline const Aws::String& GetUploadId() const{ return m_uploadId; }
+    inline bool UploadIdHasBeenSet() const { return m_uploadIdHasBeenSet; }
+    inline void SetUploadId(const Aws::String& value) { m_uploadIdHasBeenSet = true; m_uploadId = value; }
+    inline void SetUploadId(Aws::String&& value) { m_uploadIdHasBeenSet = true; m_uploadId = std::move(value); }
+    inline void SetUploadId(const char* value) { m_uploadIdHasBeenSet = true; m_uploadId.assign(value); }
+    inline CompleteMultipartUploadRequest& WithUploadId(const Aws::String& value) { SetUploadId(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithUploadId(Aws::String&& value) { SetUploadId(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithUploadId(const char* value) { SetUploadId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>This header can be used as a data integrity check to verify that the data
+     * received is the same data that was originally sent. This header specifies the
+     * base64-encoded, 32-bit CRC-32 checksum of the object. For more information, see
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32() const{ return m_checksumCRC32; }
+    inline bool ChecksumCRC32HasBeenSet() const { return m_checksumCRC32HasBeenSet; }
+    inline void SetChecksumCRC32(const Aws::String& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = value; }
+    inline void SetChecksumCRC32(Aws::String&& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = std::move(value); }
+    inline void SetChecksumCRC32(const char* value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32.assign(value); }
+    inline CompleteMultipartUploadRequest& WithChecksumCRC32(const Aws::String& value) { SetChecksumCRC32(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumCRC32(Aws::String&& value) { SetChecksumCRC32(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumCRC32(const char* value) { SetChecksumCRC32(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>This header can be used as a data integrity check to verify that the data
+     * received is the same data that was originally sent. This header specifies the
+     * base64-encoded, 32-bit CRC-32C checksum of the object. For more information, see
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32C() const{ return m_checksumCRC32C; }
+    inline bool ChecksumCRC32CHasBeenSet() const { return m_checksumCRC32CHasBeenSet; }
+    inline void SetChecksumCRC32C(const Aws::String& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = value; }
+    inline void SetChecksumCRC32C(Aws::String&& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = std::move(value); }
+    inline void SetChecksumCRC32C(const char* value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C.assign(value); }
+    inline CompleteMultipartUploadRequest& WithChecksumCRC32C(const Aws::String& value) { SetChecksumCRC32C(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumCRC32C(Aws::String&& value) { SetChecksumCRC32C(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumCRC32C(const char* value) { SetChecksumCRC32C(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>This header can be used as a data integrity check to verify that the data
+     * received is the same data that was originally sent. This header specifies the
+     * base64-encoded, 160-bit SHA-1 digest of the object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA1() const{ return m_checksumSHA1; }
+    inline bool ChecksumSHA1HasBeenSet() const { return m_checksumSHA1HasBeenSet; }
+    inline void SetChecksumSHA1(const Aws::String& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = value; }
+    inline void SetChecksumSHA1(Aws::String&& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = std::move(value); }
+    inline void SetChecksumSHA1(const char* value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1.assign(value); }
+    inline CompleteMultipartUploadRequest& WithChecksumSHA1(const Aws::String& value) { SetChecksumSHA1(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumSHA1(Aws::String&& value) { SetChecksumSHA1(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumSHA1(const char* value) { SetChecksumSHA1(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>This header can be used as a data integrity check to verify that the data
+     * received is the same data that was originally sent. This header specifies the
+     * base64-encoded, 256-bit SHA-256 digest of the object. For more information, see
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA256() const{ return m_checksumSHA256; }
+    inline bool ChecksumSHA256HasBeenSet() const { return m_checksumSHA256HasBeenSet; }
+    inline void SetChecksumSHA256(const Aws::String& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = value; }
+    inline void SetChecksumSHA256(Aws::String&& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = std::move(value); }
+    inline void SetChecksumSHA256(const char* value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256.assign(value); }
+    inline CompleteMultipartUploadRequest& WithChecksumSHA256(const Aws::String& value) { SetChecksumSHA256(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumSHA256(Aws::String&& value) { SetChecksumSHA256(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithChecksumSHA256(const char* value) { SetChecksumSHA256(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestPayer& GetRequestPayer() const{ return m_requestPayer; }
+    inline bool RequestPayerHasBeenSet() const { return m_requestPayerHasBeenSet; }
+    inline void SetRequestPayer(const RequestPayer& value) { m_requestPayerHasBeenSet = true; m_requestPayer = value; }
+    inline void SetRequestPayer(RequestPayer&& value) { m_requestPayerHasBeenSet = true; m_requestPayer = std::move(value); }
+    inline CompleteMultipartUploadRequest& WithRequestPayer(const RequestPayer& value) { SetRequestPayer(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithRequestPayer(RequestPayer&& value) { SetRequestPayer(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline CompleteMultipartUploadRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Uploads the object only if the object key name does not already exist in the
+     * bucket specified. Otherwise, Amazon S3 returns a <code>412 Precondition
+     * Failed</code> error.</p> <p>If a conflicting operation occurs during the upload
+     * S3 returns a <code>409 ConditionalRequestConflict</code> response. On a 409
+     * failure you should re-initiate the multipart upload with
+     * <code>CreateMultipartUpload</code> and re-upload each part.</p> <p>Expects the
+     * '*' (asterisk) character.</p> <p>For more information about conditional
+     * requests, see <a href="https://tools.ietf.org/html/rfc7232">RFC 7232</a>, or <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/conditional-requests.html">Conditional
+     * requests</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetIfNoneMatch() const{ return m_ifNoneMatch; }
+    inline bool IfNoneMatchHasBeenSet() const { return m_ifNoneMatchHasBeenSet; }
+    inline void SetIfNoneMatch(const Aws::String& value) { m_ifNoneMatchHasBeenSet = true; m_ifNoneMatch = value; }
+    inline void SetIfNoneMatch(Aws::String&& value) { m_ifNoneMatchHasBeenSet = true; m_ifNoneMatch = std::move(value); }
+    inline void SetIfNoneMatch(const char* value) { m_ifNoneMatchHasBeenSet = true; m_ifNoneMatch.assign(value); }
+    inline CompleteMultipartUploadRequest& WithIfNoneMatch(const Aws::String& value) { SetIfNoneMatch(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithIfNoneMatch(Aws::String&& value) { SetIfNoneMatch(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithIfNoneMatch(const char* value) { SetIfNoneMatch(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption (SSE) algorithm used to encrypt the object. This
+     * parameter is required only when the object was created using a checksum
+     * algorithm or if your bucket policy requires the use of SSE-C. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html#ssec-require-condition-key">Protecting
+     * data using SSE-C keys</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerAlgorithm() const{ return m_sSECustomerAlgorithm; }
+    inline bool SSECustomerAlgorithmHasBeenSet() const { return m_sSECustomerAlgorithmHasBeenSet; }
+    inline void SetSSECustomerAlgorithm(const Aws::String& value) { m_sSECustomerAlgorithmHasBeenSet = true; m_sSECustomerAlgorithm = value; }
+    inline void SetSSECustomerAlgorithm(Aws::String&& value) { m_sSECustomerAlgorithmHasBeenSet = true; m_sSECustomerAlgorithm = std::move(value); }
+    inline void SetSSECustomerAlgorithm(const char* value) { m_sSECustomerAlgorithmHasBeenSet = true; m_sSECustomerAlgorithm.assign(value); }
+    inline CompleteMultipartUploadRequest& WithSSECustomerAlgorithm(const Aws::String& value) { SetSSECustomerAlgorithm(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithSSECustomerAlgorithm(Aws::String&& value) { SetSSECustomerAlgorithm(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithSSECustomerAlgorithm(const char* value) { SetSSECustomerAlgorithm(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption (SSE) customer managed key. This parameter is
+     * needed only when the object was created using a checksum algorithm. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/ServerSideEncryptionCustomerKeys.html">Protecting
+     * data using SSE-C keys</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerKey() const{ return m_sSECustomerKey; }
+    inline bool SSECustomerKeyHasBeenSet() const { return m_sSECustomerKeyHasBeenSet; }
+    inline void SetSSECustomerKey(const Aws::String& value) { m_sSECustomerKeyHasBeenSet = true; m_sSECustomerKey = value; }
+    inline void SetSSECustomerKey(Aws::String&& value) { m_sSECustomerKeyHasBeenSet = true; m_sSECustomerKey = std::move(value); }
+    inline void SetSSECustomerKey(const char* value) { m_sSECustomerKeyHasBeenSet = true; m_sSECustomerKey.assign(value); }
+    inline CompleteMultipartUploadRequest& WithSSECustomerKey(const Aws::String& value) { SetSSECustomerKey(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithSSECustomerKey(Aws::String&& value) { SetSSECustomerKey(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithSSECustomerKey(const char* value) { SetSSECustomerKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The MD5 server-side encryption (SSE) customer managed key. This parameter is
+     * needed only when the object was created using a checksum algorithm. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/ServerSideEncryptionCustomerKeys.html">Protecting
+     * data using SSE-C keys</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerKeyMD5() const{ return m_sSECustomerKeyMD5; }
+    inline bool SSECustomerKeyMD5HasBeenSet() const { return m_sSECustomerKeyMD5HasBeenSet; }
+    inline void SetSSECustomerKeyMD5(const Aws::String& value) { m_sSECustomerKeyMD5HasBeenSet = true; m_sSECustomerKeyMD5 = value; }
+    inline void SetSSECustomerKeyMD5(Aws::String&& value) { m_sSECustomerKeyMD5HasBeenSet = true; m_sSECustomerKeyMD5 = std::move(value); }
+    inline void SetSSECustomerKeyMD5(const char* value) { m_sSECustomerKeyMD5HasBeenSet = true; m_sSECustomerKeyMD5.assign(value); }
+    inline CompleteMultipartUploadRequest& WithSSECustomerKeyMD5(const Aws::String& value) { SetSSECustomerKeyMD5(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithSSECustomerKeyMD5(Aws::String&& value) { SetSSECustomerKeyMD5(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& WithSSECustomerKeyMD5(const char* value) { SetSSECustomerKeyMD5(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline CompleteMultipartUploadRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline CompleteMultipartUploadRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CompleteMultipartUploadRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    CompletedMultipartUpload m_multipartUpload;
+    bool m_multipartUploadHasBeenSet = false;
+
+    Aws::String m_uploadId;
+    bool m_uploadIdHasBeenSet = false;
+
+    Aws::String m_checksumCRC32;
+    bool m_checksumCRC32HasBeenSet = false;
+
+    Aws::String m_checksumCRC32C;
+    bool m_checksumCRC32CHasBeenSet = false;
+
+    Aws::String m_checksumSHA1;
+    bool m_checksumSHA1HasBeenSet = false;
+
+    Aws::String m_checksumSHA256;
+    bool m_checksumSHA256HasBeenSet = false;
+
+    RequestPayer m_requestPayer;
+    bool m_requestPayerHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::String m_ifNoneMatch;
+    bool m_ifNoneMatchHasBeenSet = false;
+
+    Aws::String m_sSECustomerAlgorithm;
+    bool m_sSECustomerAlgorithmHasBeenSet = false;
+
+    Aws::String m_sSECustomerKey;
+    bool m_sSECustomerKeyHasBeenSet = false;
+
+    Aws::String m_sSECustomerKeyMD5;
+    bool m_sSECustomerKeyMD5HasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CompleteMultipartUploadResult.h

@@ -0,0 +1,300 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/s3/model/RequestCharged.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class CompleteMultipartUploadResult
+  {
+  public:
+    AWS_S3_API CompleteMultipartUploadResult();
+    AWS_S3_API CompleteMultipartUploadResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API CompleteMultipartUploadResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The URI that identifies the newly created object.</p>
+     */
+    inline const Aws::String& GetLocation() const{ return m_location; }
+    inline void SetLocation(const Aws::String& value) { m_location = value; }
+    inline void SetLocation(Aws::String&& value) { m_location = std::move(value); }
+    inline void SetLocation(const char* value) { m_location.assign(value); }
+    inline CompleteMultipartUploadResult& WithLocation(const Aws::String& value) { SetLocation(value); return *this;}
+    inline CompleteMultipartUploadResult& WithLocation(Aws::String&& value) { SetLocation(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithLocation(const char* value) { SetLocation(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The name of the bucket that contains the newly created object. Does not
+     * return the access point ARN or access point alias if used.</p>  <p>Access
+     * points are not supported by directory buckets.</p> 
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline void SetBucket(const Aws::String& value) { m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucket.assign(value); }
+    inline CompleteMultipartUploadResult& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline CompleteMultipartUploadResult& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The object key of the newly created object.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline void SetKey(const Aws::String& value) { m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_key.assign(value); }
+    inline CompleteMultipartUploadResult& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline CompleteMultipartUploadResult& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If the object expiration is configured, this will contain the expiration date
+     * (<code>expiry-date</code>) and rule ID (<code>rule-id</code>). The value of
+     * <code>rule-id</code> is URL-encoded.</p>  <p>This functionality is not
+     * supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetExpiration() const{ return m_expiration; }
+    inline void SetExpiration(const Aws::String& value) { m_expiration = value; }
+    inline void SetExpiration(Aws::String&& value) { m_expiration = std::move(value); }
+    inline void SetExpiration(const char* value) { m_expiration.assign(value); }
+    inline CompleteMultipartUploadResult& WithExpiration(const Aws::String& value) { SetExpiration(value); return *this;}
+    inline CompleteMultipartUploadResult& WithExpiration(Aws::String&& value) { SetExpiration(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithExpiration(const char* value) { SetExpiration(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Entity tag that identifies the newly created object's data. Objects with
+     * different object data will have different entity tags. The entity tag is an
+     * opaque string. The entity tag may or may not be an MD5 digest of the object
+     * data. If the entity tag is not an MD5 digest of the object data, it will contain
+     * one or more nonhexadecimal characters and/or will consist of less than 32 or
+     * more than 32 hexadecimal digits. For more information about how the entity tag
+     * is calculated, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetETag() const{ return m_eTag; }
+    inline void SetETag(const Aws::String& value) { m_eTag = value; }
+    inline void SetETag(Aws::String&& value) { m_eTag = std::move(value); }
+    inline void SetETag(const char* value) { m_eTag.assign(value); }
+    inline CompleteMultipartUploadResult& WithETag(const Aws::String& value) { SetETag(value); return *this;}
+    inline CompleteMultipartUploadResult& WithETag(Aws::String&& value) { SetETag(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithETag(const char* value) { SetETag(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32 checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32() const{ return m_checksumCRC32; }
+    inline void SetChecksumCRC32(const Aws::String& value) { m_checksumCRC32 = value; }
+    inline void SetChecksumCRC32(Aws::String&& value) { m_checksumCRC32 = std::move(value); }
+    inline void SetChecksumCRC32(const char* value) { m_checksumCRC32.assign(value); }
+    inline CompleteMultipartUploadResult& WithChecksumCRC32(const Aws::String& value) { SetChecksumCRC32(value); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumCRC32(Aws::String&& value) { SetChecksumCRC32(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumCRC32(const char* value) { SetChecksumCRC32(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32C checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32C() const{ return m_checksumCRC32C; }
+    inline void SetChecksumCRC32C(const Aws::String& value) { m_checksumCRC32C = value; }
+    inline void SetChecksumCRC32C(Aws::String&& value) { m_checksumCRC32C = std::move(value); }
+    inline void SetChecksumCRC32C(const char* value) { m_checksumCRC32C.assign(value); }
+    inline CompleteMultipartUploadResult& WithChecksumCRC32C(const Aws::String& value) { SetChecksumCRC32C(value); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumCRC32C(Aws::String&& value) { SetChecksumCRC32C(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumCRC32C(const char* value) { SetChecksumCRC32C(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 160-bit SHA-1 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use the API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA1() const{ return m_checksumSHA1; }
+    inline void SetChecksumSHA1(const Aws::String& value) { m_checksumSHA1 = value; }
+    inline void SetChecksumSHA1(Aws::String&& value) { m_checksumSHA1 = std::move(value); }
+    inline void SetChecksumSHA1(const char* value) { m_checksumSHA1.assign(value); }
+    inline CompleteMultipartUploadResult& WithChecksumSHA1(const Aws::String& value) { SetChecksumSHA1(value); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumSHA1(Aws::String&& value) { SetChecksumSHA1(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumSHA1(const char* value) { SetChecksumSHA1(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 256-bit SHA-256 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA256() const{ return m_checksumSHA256; }
+    inline void SetChecksumSHA256(const Aws::String& value) { m_checksumSHA256 = value; }
+    inline void SetChecksumSHA256(Aws::String&& value) { m_checksumSHA256 = std::move(value); }
+    inline void SetChecksumSHA256(const char* value) { m_checksumSHA256.assign(value); }
+    inline CompleteMultipartUploadResult& WithChecksumSHA256(const Aws::String& value) { SetChecksumSHA256(value); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumSHA256(Aws::String&& value) { SetChecksumSHA256(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithChecksumSHA256(const char* value) { SetChecksumSHA256(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm used when storing this object in Amazon
+     * S3 (for example, <code>AES256</code>, <code>aws:kms</code>).</p>
+     */
+    inline const ServerSideEncryption& GetServerSideEncryption() const{ return m_serverSideEncryption; }
+    inline void SetServerSideEncryption(const ServerSideEncryption& value) { m_serverSideEncryption = value; }
+    inline void SetServerSideEncryption(ServerSideEncryption&& value) { m_serverSideEncryption = std::move(value); }
+    inline CompleteMultipartUploadResult& WithServerSideEncryption(const ServerSideEncryption& value) { SetServerSideEncryption(value); return *this;}
+    inline CompleteMultipartUploadResult& WithServerSideEncryption(ServerSideEncryption&& value) { SetServerSideEncryption(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Version ID of the newly created object, in case the bucket has versioning
+     * turned on.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline void SetVersionId(const Aws::String& value) { m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionId.assign(value); }
+    inline CompleteMultipartUploadResult& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline CompleteMultipartUploadResult& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If present, indicates the ID of the KMS key that was used for object
+     * encryption.</p>
+     */
+    inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
+    inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyId = value; }
+    inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyId = std::move(value); }
+    inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyId.assign(value); }
+    inline CompleteMultipartUploadResult& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
+    inline CompleteMultipartUploadResult& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates whether the multipart upload uses an S3 Bucket Key for server-side
+     * encryption with Key Management Service (KMS) keys (SSE-KMS).</p>
+     */
+    inline bool GetBucketKeyEnabled() const{ return m_bucketKeyEnabled; }
+    inline void SetBucketKeyEnabled(bool value) { m_bucketKeyEnabled = value; }
+    inline CompleteMultipartUploadResult& WithBucketKeyEnabled(bool value) { SetBucketKeyEnabled(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestCharged& GetRequestCharged() const{ return m_requestCharged; }
+    inline void SetRequestCharged(const RequestCharged& value) { m_requestCharged = value; }
+    inline void SetRequestCharged(RequestCharged&& value) { m_requestCharged = std::move(value); }
+    inline CompleteMultipartUploadResult& WithRequestCharged(const RequestCharged& value) { SetRequestCharged(value); return *this;}
+    inline CompleteMultipartUploadResult& WithRequestCharged(RequestCharged&& value) { SetRequestCharged(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline CompleteMultipartUploadResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline CompleteMultipartUploadResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline CompleteMultipartUploadResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_location;
+
+    Aws::String m_bucket;
+
+    Aws::String m_key;
+
+    Aws::String m_expiration;
+
+    Aws::String m_eTag;
+
+    Aws::String m_checksumCRC32;
+
+    Aws::String m_checksumCRC32C;
+
+    Aws::String m_checksumSHA1;
+
+    Aws::String m_checksumSHA256;
+
+    ServerSideEncryption m_serverSideEncryption;
+
+    Aws::String m_versionId;
+
+    Aws::String m_sSEKMSKeyId;
+
+    bool m_bucketKeyEnabled;
+
+    RequestCharged m_requestCharged;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CompletedMultipartUpload.h

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/CompletedPart.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>The container for the completed multipart upload details.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompletedMultipartUpload">AWS
+   * API Reference</a></p>
+   */
+  class CompletedMultipartUpload
+  {
+  public:
+    AWS_S3_API CompletedMultipartUpload();
+    AWS_S3_API CompletedMultipartUpload(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CompletedMultipartUpload& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Array of CompletedPart data types.</p> <p>If you do not supply a valid
+     * <code>Part</code> with your request, the service sends back an HTTP 400
+     * response.</p>
+     */
+    inline const Aws::Vector<CompletedPart>& GetParts() const{ return m_parts; }
+    inline bool PartsHasBeenSet() const { return m_partsHasBeenSet; }
+    inline void SetParts(const Aws::Vector<CompletedPart>& value) { m_partsHasBeenSet = true; m_parts = value; }
+    inline void SetParts(Aws::Vector<CompletedPart>&& value) { m_partsHasBeenSet = true; m_parts = std::move(value); }
+    inline CompletedMultipartUpload& WithParts(const Aws::Vector<CompletedPart>& value) { SetParts(value); return *this;}
+    inline CompletedMultipartUpload& WithParts(Aws::Vector<CompletedPart>&& value) { SetParts(std::move(value)); return *this;}
+    inline CompletedMultipartUpload& AddParts(const CompletedPart& value) { m_partsHasBeenSet = true; m_parts.push_back(value); return *this; }
+    inline CompletedMultipartUpload& AddParts(CompletedPart&& value) { m_partsHasBeenSet = true; m_parts.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::Vector<CompletedPart> m_parts;
+    bool m_partsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CompletedPart.h

@@ -0,0 +1,180 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Details of the parts that were uploaded.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CompletedPart">AWS
+   * API Reference</a></p>
+   */
+  class CompletedPart
+  {
+  public:
+    AWS_S3_API CompletedPart();
+    AWS_S3_API CompletedPart(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CompletedPart& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Entity tag returned when the part was uploaded.</p>
+     */
+    inline const Aws::String& GetETag() const{ return m_eTag; }
+    inline bool ETagHasBeenSet() const { return m_eTagHasBeenSet; }
+    inline void SetETag(const Aws::String& value) { m_eTagHasBeenSet = true; m_eTag = value; }
+    inline void SetETag(Aws::String&& value) { m_eTagHasBeenSet = true; m_eTag = std::move(value); }
+    inline void SetETag(const char* value) { m_eTagHasBeenSet = true; m_eTag.assign(value); }
+    inline CompletedPart& WithETag(const Aws::String& value) { SetETag(value); return *this;}
+    inline CompletedPart& WithETag(Aws::String&& value) { SetETag(std::move(value)); return *this;}
+    inline CompletedPart& WithETag(const char* value) { SetETag(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32 checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32() const{ return m_checksumCRC32; }
+    inline bool ChecksumCRC32HasBeenSet() const { return m_checksumCRC32HasBeenSet; }
+    inline void SetChecksumCRC32(const Aws::String& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = value; }
+    inline void SetChecksumCRC32(Aws::String&& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = std::move(value); }
+    inline void SetChecksumCRC32(const char* value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32.assign(value); }
+    inline CompletedPart& WithChecksumCRC32(const Aws::String& value) { SetChecksumCRC32(value); return *this;}
+    inline CompletedPart& WithChecksumCRC32(Aws::String&& value) { SetChecksumCRC32(std::move(value)); return *this;}
+    inline CompletedPart& WithChecksumCRC32(const char* value) { SetChecksumCRC32(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32C checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32C() const{ return m_checksumCRC32C; }
+    inline bool ChecksumCRC32CHasBeenSet() const { return m_checksumCRC32CHasBeenSet; }
+    inline void SetChecksumCRC32C(const Aws::String& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = value; }
+    inline void SetChecksumCRC32C(Aws::String&& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = std::move(value); }
+    inline void SetChecksumCRC32C(const char* value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C.assign(value); }
+    inline CompletedPart& WithChecksumCRC32C(const Aws::String& value) { SetChecksumCRC32C(value); return *this;}
+    inline CompletedPart& WithChecksumCRC32C(Aws::String&& value) { SetChecksumCRC32C(std::move(value)); return *this;}
+    inline CompletedPart& WithChecksumCRC32C(const char* value) { SetChecksumCRC32C(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 160-bit SHA-1 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use the API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA1() const{ return m_checksumSHA1; }
+    inline bool ChecksumSHA1HasBeenSet() const { return m_checksumSHA1HasBeenSet; }
+    inline void SetChecksumSHA1(const Aws::String& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = value; }
+    inline void SetChecksumSHA1(Aws::String&& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = std::move(value); }
+    inline void SetChecksumSHA1(const char* value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1.assign(value); }
+    inline CompletedPart& WithChecksumSHA1(const Aws::String& value) { SetChecksumSHA1(value); return *this;}
+    inline CompletedPart& WithChecksumSHA1(Aws::String&& value) { SetChecksumSHA1(std::move(value)); return *this;}
+    inline CompletedPart& WithChecksumSHA1(const char* value) { SetChecksumSHA1(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 256-bit SHA-256 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA256() const{ return m_checksumSHA256; }
+    inline bool ChecksumSHA256HasBeenSet() const { return m_checksumSHA256HasBeenSet; }
+    inline void SetChecksumSHA256(const Aws::String& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = value; }
+    inline void SetChecksumSHA256(Aws::String&& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = std::move(value); }
+    inline void SetChecksumSHA256(const char* value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256.assign(value); }
+    inline CompletedPart& WithChecksumSHA256(const Aws::String& value) { SetChecksumSHA256(value); return *this;}
+    inline CompletedPart& WithChecksumSHA256(Aws::String&& value) { SetChecksumSHA256(std::move(value)); return *this;}
+    inline CompletedPart& WithChecksumSHA256(const char* value) { SetChecksumSHA256(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Part number that identifies the part. This is a positive integer between 1
+     * and 10,000.</p>  <ul> <li> <p> <b>General purpose buckets</b> - In
+     * <code>CompleteMultipartUpload</code>, when a additional checksum (including
+     * <code>x-amz-checksum-crc32</code>, <code>x-amz-checksum-crc32c</code>,
+     * <code>x-amz-checksum-sha1</code>, or <code>x-amz-checksum-sha256</code>) is
+     * applied to each part, the <code>PartNumber</code> must start at 1 and the part
+     * numbers must be consecutive. Otherwise, Amazon S3 generates an HTTP <code>400
+     * Bad Request</code> status code and an <code>InvalidPartOrder</code> error
+     * code.</p> </li> <li> <p> <b>Directory buckets</b> - In
+     * <code>CompleteMultipartUpload</code>, the <code>PartNumber</code> must start at
+     * 1 and the part numbers must be consecutive.</p> </li> </ul> 
+     */
+    inline int GetPartNumber() const{ return m_partNumber; }
+    inline bool PartNumberHasBeenSet() const { return m_partNumberHasBeenSet; }
+    inline void SetPartNumber(int value) { m_partNumberHasBeenSet = true; m_partNumber = value; }
+    inline CompletedPart& WithPartNumber(int value) { SetPartNumber(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_eTag;
+    bool m_eTagHasBeenSet = false;
+
+    Aws::String m_checksumCRC32;
+    bool m_checksumCRC32HasBeenSet = false;
+
+    Aws::String m_checksumCRC32C;
+    bool m_checksumCRC32CHasBeenSet = false;
+
+    Aws::String m_checksumSHA1;
+    bool m_checksumSHA1HasBeenSet = false;
+
+    Aws::String m_checksumSHA256;
+    bool m_checksumSHA256HasBeenSet = false;
+
+    int m_partNumber;
+    bool m_partNumberHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CompressionType.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class CompressionType
+  {
+    NOT_SET,
+    NONE,
+    GZIP,
+    BZIP2
+  };
+
+namespace CompressionTypeMapper
+{
+AWS_S3_API CompressionType GetCompressionTypeForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForCompressionType(CompressionType value);
+} // namespace CompressionTypeMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Condition.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>A container for describing a condition that must be met for the specified
+   * redirect to apply. For example, 1. If request is for pages in the
+   * <code>/docs</code> folder, redirect to the <code>/documents</code> folder. 2. If
+   * request results in HTTP error 4xx, redirect request to another host where you
+   * might process the error.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Condition">AWS API
+   * Reference</a></p>
+   */
+  class Condition
+  {
+  public:
+    AWS_S3_API Condition();
+    AWS_S3_API Condition(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Condition& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The HTTP error code when the redirect is applied. In the event of an error,
+     * if the error code equals this value, then the specified redirect is applied.
+     * Required when parent element <code>Condition</code> is specified and sibling
+     * <code>KeyPrefixEquals</code> is not specified. If both are specified, then both
+     * must be true for the redirect to be applied.</p>
+     */
+    inline const Aws::String& GetHttpErrorCodeReturnedEquals() const{ return m_httpErrorCodeReturnedEquals; }
+    inline bool HttpErrorCodeReturnedEqualsHasBeenSet() const { return m_httpErrorCodeReturnedEqualsHasBeenSet; }
+    inline void SetHttpErrorCodeReturnedEquals(const Aws::String& value) { m_httpErrorCodeReturnedEqualsHasBeenSet = true; m_httpErrorCodeReturnedEquals = value; }
+    inline void SetHttpErrorCodeReturnedEquals(Aws::String&& value) { m_httpErrorCodeReturnedEqualsHasBeenSet = true; m_httpErrorCodeReturnedEquals = std::move(value); }
+    inline void SetHttpErrorCodeReturnedEquals(const char* value) { m_httpErrorCodeReturnedEqualsHasBeenSet = true; m_httpErrorCodeReturnedEquals.assign(value); }
+    inline Condition& WithHttpErrorCodeReturnedEquals(const Aws::String& value) { SetHttpErrorCodeReturnedEquals(value); return *this;}
+    inline Condition& WithHttpErrorCodeReturnedEquals(Aws::String&& value) { SetHttpErrorCodeReturnedEquals(std::move(value)); return *this;}
+    inline Condition& WithHttpErrorCodeReturnedEquals(const char* value) { SetHttpErrorCodeReturnedEquals(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The object key name prefix when the redirect is applied. For example, to
+     * redirect requests for <code>ExamplePage.html</code>, the key prefix will be
+     * <code>ExamplePage.html</code>. To redirect request for all pages with the prefix
+     * <code>docs/</code>, the key prefix will be <code>/docs</code>, which identifies
+     * all objects in the <code>docs/</code> folder. Required when the parent element
+     * <code>Condition</code> is specified and sibling
+     * <code>HttpErrorCodeReturnedEquals</code> is not specified. If both conditions
+     * are specified, both must be true for the redirect to be applied.</p> 
+     * <p>Replacement must be made for object keys containing special characters (such
+     * as carriage returns) when using XML requests. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints">
+     * XML related object key constraints</a>.</p> 
+     */
+    inline const Aws::String& GetKeyPrefixEquals() const{ return m_keyPrefixEquals; }
+    inline bool KeyPrefixEqualsHasBeenSet() const { return m_keyPrefixEqualsHasBeenSet; }
+    inline void SetKeyPrefixEquals(const Aws::String& value) { m_keyPrefixEqualsHasBeenSet = true; m_keyPrefixEquals = value; }
+    inline void SetKeyPrefixEquals(Aws::String&& value) { m_keyPrefixEqualsHasBeenSet = true; m_keyPrefixEquals = std::move(value); }
+    inline void SetKeyPrefixEquals(const char* value) { m_keyPrefixEqualsHasBeenSet = true; m_keyPrefixEquals.assign(value); }
+    inline Condition& WithKeyPrefixEquals(const Aws::String& value) { SetKeyPrefixEquals(value); return *this;}
+    inline Condition& WithKeyPrefixEquals(Aws::String&& value) { SetKeyPrefixEquals(std::move(value)); return *this;}
+    inline Condition& WithKeyPrefixEquals(const char* value) { SetKeyPrefixEquals(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_httpErrorCodeReturnedEquals;
+    bool m_httpErrorCodeReturnedEqualsHasBeenSet = false;
+
+    Aws::String m_keyPrefixEquals;
+    bool m_keyPrefixEqualsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CopyObjectResult.h

@@ -0,0 +1,225 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/s3/model/RequestCharged.h>
+#include <aws/s3/model/CopyObjectResultDetails.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class CopyObjectResult
+  {
+  public:
+    AWS_S3_API CopyObjectResult();
+    AWS_S3_API CopyObjectResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API CopyObjectResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>If the object expiration is configured, the response includes this
+     * header.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetExpiration() const{ return m_expiration; }
+    inline void SetExpiration(const Aws::String& value) { m_expiration = value; }
+    inline void SetExpiration(Aws::String&& value) { m_expiration = std::move(value); }
+    inline void SetExpiration(const char* value) { m_expiration.assign(value); }
+    inline CopyObjectResult& WithExpiration(const Aws::String& value) { SetExpiration(value); return *this;}
+    inline CopyObjectResult& WithExpiration(Aws::String&& value) { SetExpiration(std::move(value)); return *this;}
+    inline CopyObjectResult& WithExpiration(const char* value) { SetExpiration(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Version ID of the source object that was copied.</p>  <p>This
+     * functionality is not supported when the source object is in a directory
+     * bucket.</p> 
+     */
+    inline const Aws::String& GetCopySourceVersionId() const{ return m_copySourceVersionId; }
+    inline void SetCopySourceVersionId(const Aws::String& value) { m_copySourceVersionId = value; }
+    inline void SetCopySourceVersionId(Aws::String&& value) { m_copySourceVersionId = std::move(value); }
+    inline void SetCopySourceVersionId(const char* value) { m_copySourceVersionId.assign(value); }
+    inline CopyObjectResult& WithCopySourceVersionId(const Aws::String& value) { SetCopySourceVersionId(value); return *this;}
+    inline CopyObjectResult& WithCopySourceVersionId(Aws::String&& value) { SetCopySourceVersionId(std::move(value)); return *this;}
+    inline CopyObjectResult& WithCopySourceVersionId(const char* value) { SetCopySourceVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Version ID of the newly created copy.</p>  <p>This functionality is not
+     * supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline void SetVersionId(const Aws::String& value) { m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionId.assign(value); }
+    inline CopyObjectResult& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline CopyObjectResult& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline CopyObjectResult& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm used when you store this object in
+     * Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>,
+     * <code>aws:kms:dsse</code>).</p>
+     */
+    inline const ServerSideEncryption& GetServerSideEncryption() const{ return m_serverSideEncryption; }
+    inline void SetServerSideEncryption(const ServerSideEncryption& value) { m_serverSideEncryption = value; }
+    inline void SetServerSideEncryption(ServerSideEncryption&& value) { m_serverSideEncryption = std::move(value); }
+    inline CopyObjectResult& WithServerSideEncryption(const ServerSideEncryption& value) { SetServerSideEncryption(value); return *this;}
+    inline CopyObjectResult& WithServerSideEncryption(ServerSideEncryption&& value) { SetServerSideEncryption(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If server-side encryption with a customer-provided encryption key was
+     * requested, the response will include this header to confirm the encryption
+     * algorithm that's used.</p>  <p>This functionality is not supported for
+     * directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerAlgorithm() const{ return m_sSECustomerAlgorithm; }
+    inline void SetSSECustomerAlgorithm(const Aws::String& value) { m_sSECustomerAlgorithm = value; }
+    inline void SetSSECustomerAlgorithm(Aws::String&& value) { m_sSECustomerAlgorithm = std::move(value); }
+    inline void SetSSECustomerAlgorithm(const char* value) { m_sSECustomerAlgorithm.assign(value); }
+    inline CopyObjectResult& WithSSECustomerAlgorithm(const Aws::String& value) { SetSSECustomerAlgorithm(value); return *this;}
+    inline CopyObjectResult& WithSSECustomerAlgorithm(Aws::String&& value) { SetSSECustomerAlgorithm(std::move(value)); return *this;}
+    inline CopyObjectResult& WithSSECustomerAlgorithm(const char* value) { SetSSECustomerAlgorithm(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If server-side encryption with a customer-provided encryption key was
+     * requested, the response will include this header to provide the round-trip
+     * message integrity verification of the customer-provided encryption key.</p>
+     *  <p>This functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerKeyMD5() const{ return m_sSECustomerKeyMD5; }
+    inline void SetSSECustomerKeyMD5(const Aws::String& value) { m_sSECustomerKeyMD5 = value; }
+    inline void SetSSECustomerKeyMD5(Aws::String&& value) { m_sSECustomerKeyMD5 = std::move(value); }
+    inline void SetSSECustomerKeyMD5(const char* value) { m_sSECustomerKeyMD5.assign(value); }
+    inline CopyObjectResult& WithSSECustomerKeyMD5(const Aws::String& value) { SetSSECustomerKeyMD5(value); return *this;}
+    inline CopyObjectResult& WithSSECustomerKeyMD5(Aws::String&& value) { SetSSECustomerKeyMD5(std::move(value)); return *this;}
+    inline CopyObjectResult& WithSSECustomerKeyMD5(const char* value) { SetSSECustomerKeyMD5(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If present, indicates the ID of the KMS key that was used for object
+     * encryption.</p>
+     */
+    inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
+    inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyId = value; }
+    inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyId = std::move(value); }
+    inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyId.assign(value); }
+    inline CopyObjectResult& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
+    inline CopyObjectResult& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
+    inline CopyObjectResult& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If present, indicates the Amazon Web Services KMS Encryption Context to use
+     * for object encryption. The value of this header is a base64-encoded UTF-8 string
+     * holding JSON with the encryption context key-value pairs.</p>
+     */
+    inline const Aws::String& GetSSEKMSEncryptionContext() const{ return m_sSEKMSEncryptionContext; }
+    inline void SetSSEKMSEncryptionContext(const Aws::String& value) { m_sSEKMSEncryptionContext = value; }
+    inline void SetSSEKMSEncryptionContext(Aws::String&& value) { m_sSEKMSEncryptionContext = std::move(value); }
+    inline void SetSSEKMSEncryptionContext(const char* value) { m_sSEKMSEncryptionContext.assign(value); }
+    inline CopyObjectResult& WithSSEKMSEncryptionContext(const Aws::String& value) { SetSSEKMSEncryptionContext(value); return *this;}
+    inline CopyObjectResult& WithSSEKMSEncryptionContext(Aws::String&& value) { SetSSEKMSEncryptionContext(std::move(value)); return *this;}
+    inline CopyObjectResult& WithSSEKMSEncryptionContext(const char* value) { SetSSEKMSEncryptionContext(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates whether the copied object uses an S3 Bucket Key for server-side
+     * encryption with Key Management Service (KMS) keys (SSE-KMS).</p>
+     */
+    inline bool GetBucketKeyEnabled() const{ return m_bucketKeyEnabled; }
+    inline void SetBucketKeyEnabled(bool value) { m_bucketKeyEnabled = value; }
+    inline CopyObjectResult& WithBucketKeyEnabled(bool value) { SetBucketKeyEnabled(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestCharged& GetRequestCharged() const{ return m_requestCharged; }
+    inline void SetRequestCharged(const RequestCharged& value) { m_requestCharged = value; }
+    inline void SetRequestCharged(RequestCharged&& value) { m_requestCharged = std::move(value); }
+    inline CopyObjectResult& WithRequestCharged(const RequestCharged& value) { SetRequestCharged(value); return *this;}
+    inline CopyObjectResult& WithRequestCharged(RequestCharged&& value) { SetRequestCharged(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Container for all response elements.</p>
+     */
+    inline const CopyObjectResultDetails& GetCopyObjectResultDetails() const{ return m_copyObjectResultDetails; }
+    inline void SetCopyObjectResultDetails(const CopyObjectResultDetails& value) { m_copyObjectResultDetails = value; }
+    inline void SetCopyObjectResultDetails(CopyObjectResultDetails&& value) { m_copyObjectResultDetails = std::move(value); }
+    inline CopyObjectResult& WithCopyObjectResultDetails(const CopyObjectResultDetails& value) { SetCopyObjectResultDetails(value); return *this;}
+    inline CopyObjectResult& WithCopyObjectResultDetails(CopyObjectResultDetails&& value) { SetCopyObjectResultDetails(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline CopyObjectResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline CopyObjectResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline CopyObjectResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_expiration;
+
+    Aws::String m_copySourceVersionId;
+
+    Aws::String m_versionId;
+
+    ServerSideEncryption m_serverSideEncryption;
+
+    Aws::String m_sSECustomerAlgorithm;
+
+    Aws::String m_sSECustomerKeyMD5;
+
+    Aws::String m_sSEKMSKeyId;
+
+    Aws::String m_sSEKMSEncryptionContext;
+
+    bool m_bucketKeyEnabled;
+
+    RequestCharged m_requestCharged;
+
+    CopyObjectResultDetails m_copyObjectResultDetails;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CopyObjectResultDetails.h

@@ -0,0 +1,158 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for all response elements.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyObjectResult">AWS
+   * API Reference</a></p>
+   */
+  class CopyObjectResultDetails
+  {
+  public:
+    AWS_S3_API CopyObjectResultDetails();
+    AWS_S3_API CopyObjectResultDetails(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CopyObjectResultDetails& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Returns the ETag of the new object. The ETag reflects only changes to the
+     * contents of an object, not its metadata.</p>
+     */
+    inline const Aws::String& GetETag() const{ return m_eTag; }
+    inline bool ETagHasBeenSet() const { return m_eTagHasBeenSet; }
+    inline void SetETag(const Aws::String& value) { m_eTagHasBeenSet = true; m_eTag = value; }
+    inline void SetETag(Aws::String&& value) { m_eTagHasBeenSet = true; m_eTag = std::move(value); }
+    inline void SetETag(const char* value) { m_eTagHasBeenSet = true; m_eTag.assign(value); }
+    inline CopyObjectResultDetails& WithETag(const Aws::String& value) { SetETag(value); return *this;}
+    inline CopyObjectResultDetails& WithETag(Aws::String&& value) { SetETag(std::move(value)); return *this;}
+    inline CopyObjectResultDetails& WithETag(const char* value) { SetETag(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Creation date of the object.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLastModified() const{ return m_lastModified; }
+    inline bool LastModifiedHasBeenSet() const { return m_lastModifiedHasBeenSet; }
+    inline void SetLastModified(const Aws::Utils::DateTime& value) { m_lastModifiedHasBeenSet = true; m_lastModified = value; }
+    inline void SetLastModified(Aws::Utils::DateTime&& value) { m_lastModifiedHasBeenSet = true; m_lastModified = std::move(value); }
+    inline CopyObjectResultDetails& WithLastModified(const Aws::Utils::DateTime& value) { SetLastModified(value); return *this;}
+    inline CopyObjectResultDetails& WithLastModified(Aws::Utils::DateTime&& value) { SetLastModified(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32 checksum of the object. This will only be
+     * present if it was uploaded with the object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32() const{ return m_checksumCRC32; }
+    inline bool ChecksumCRC32HasBeenSet() const { return m_checksumCRC32HasBeenSet; }
+    inline void SetChecksumCRC32(const Aws::String& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = value; }
+    inline void SetChecksumCRC32(Aws::String&& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = std::move(value); }
+    inline void SetChecksumCRC32(const char* value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32.assign(value); }
+    inline CopyObjectResultDetails& WithChecksumCRC32(const Aws::String& value) { SetChecksumCRC32(value); return *this;}
+    inline CopyObjectResultDetails& WithChecksumCRC32(Aws::String&& value) { SetChecksumCRC32(std::move(value)); return *this;}
+    inline CopyObjectResultDetails& WithChecksumCRC32(const char* value) { SetChecksumCRC32(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32C checksum of the object. This will only be
+     * present if it was uploaded with the object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32C() const{ return m_checksumCRC32C; }
+    inline bool ChecksumCRC32CHasBeenSet() const { return m_checksumCRC32CHasBeenSet; }
+    inline void SetChecksumCRC32C(const Aws::String& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = value; }
+    inline void SetChecksumCRC32C(Aws::String&& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = std::move(value); }
+    inline void SetChecksumCRC32C(const char* value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C.assign(value); }
+    inline CopyObjectResultDetails& WithChecksumCRC32C(const Aws::String& value) { SetChecksumCRC32C(value); return *this;}
+    inline CopyObjectResultDetails& WithChecksumCRC32C(Aws::String&& value) { SetChecksumCRC32C(std::move(value)); return *this;}
+    inline CopyObjectResultDetails& WithChecksumCRC32C(const char* value) { SetChecksumCRC32C(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 160-bit SHA-1 digest of the object. This will only be
+     * present if it was uploaded with the object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA1() const{ return m_checksumSHA1; }
+    inline bool ChecksumSHA1HasBeenSet() const { return m_checksumSHA1HasBeenSet; }
+    inline void SetChecksumSHA1(const Aws::String& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = value; }
+    inline void SetChecksumSHA1(Aws::String&& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = std::move(value); }
+    inline void SetChecksumSHA1(const char* value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1.assign(value); }
+    inline CopyObjectResultDetails& WithChecksumSHA1(const Aws::String& value) { SetChecksumSHA1(value); return *this;}
+    inline CopyObjectResultDetails& WithChecksumSHA1(Aws::String&& value) { SetChecksumSHA1(std::move(value)); return *this;}
+    inline CopyObjectResultDetails& WithChecksumSHA1(const char* value) { SetChecksumSHA1(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 256-bit SHA-256 digest of the object. This will only be
+     * present if it was uploaded with the object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA256() const{ return m_checksumSHA256; }
+    inline bool ChecksumSHA256HasBeenSet() const { return m_checksumSHA256HasBeenSet; }
+    inline void SetChecksumSHA256(const Aws::String& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = value; }
+    inline void SetChecksumSHA256(Aws::String&& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = std::move(value); }
+    inline void SetChecksumSHA256(const char* value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256.assign(value); }
+    inline CopyObjectResultDetails& WithChecksumSHA256(const Aws::String& value) { SetChecksumSHA256(value); return *this;}
+    inline CopyObjectResultDetails& WithChecksumSHA256(Aws::String&& value) { SetChecksumSHA256(std::move(value)); return *this;}
+    inline CopyObjectResultDetails& WithChecksumSHA256(const char* value) { SetChecksumSHA256(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_eTag;
+    bool m_eTagHasBeenSet = false;
+
+    Aws::Utils::DateTime m_lastModified;
+    bool m_lastModifiedHasBeenSet = false;
+
+    Aws::String m_checksumCRC32;
+    bool m_checksumCRC32HasBeenSet = false;
+
+    Aws::String m_checksumCRC32C;
+    bool m_checksumCRC32CHasBeenSet = false;
+
+    Aws::String m_checksumSHA1;
+    bool m_checksumSHA1HasBeenSet = false;
+
+    Aws::String m_checksumSHA256;
+    bool m_checksumSHA256HasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CopyPartResult.h

@@ -0,0 +1,173 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for all response elements.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CopyPartResult">AWS
+   * API Reference</a></p>
+   */
+  class CopyPartResult
+  {
+  public:
+    AWS_S3_API CopyPartResult();
+    AWS_S3_API CopyPartResult(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CopyPartResult& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Entity tag of the object.</p>
+     */
+    inline const Aws::String& GetETag() const{ return m_eTag; }
+    inline bool ETagHasBeenSet() const { return m_eTagHasBeenSet; }
+    inline void SetETag(const Aws::String& value) { m_eTagHasBeenSet = true; m_eTag = value; }
+    inline void SetETag(Aws::String&& value) { m_eTagHasBeenSet = true; m_eTag = std::move(value); }
+    inline void SetETag(const char* value) { m_eTagHasBeenSet = true; m_eTag.assign(value); }
+    inline CopyPartResult& WithETag(const Aws::String& value) { SetETag(value); return *this;}
+    inline CopyPartResult& WithETag(Aws::String&& value) { SetETag(std::move(value)); return *this;}
+    inline CopyPartResult& WithETag(const char* value) { SetETag(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Date and time at which the object was uploaded.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLastModified() const{ return m_lastModified; }
+    inline bool LastModifiedHasBeenSet() const { return m_lastModifiedHasBeenSet; }
+    inline void SetLastModified(const Aws::Utils::DateTime& value) { m_lastModifiedHasBeenSet = true; m_lastModified = value; }
+    inline void SetLastModified(Aws::Utils::DateTime&& value) { m_lastModifiedHasBeenSet = true; m_lastModified = std::move(value); }
+    inline CopyPartResult& WithLastModified(const Aws::Utils::DateTime& value) { SetLastModified(value); return *this;}
+    inline CopyPartResult& WithLastModified(Aws::Utils::DateTime&& value) { SetLastModified(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32 checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32() const{ return m_checksumCRC32; }
+    inline bool ChecksumCRC32HasBeenSet() const { return m_checksumCRC32HasBeenSet; }
+    inline void SetChecksumCRC32(const Aws::String& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = value; }
+    inline void SetChecksumCRC32(Aws::String&& value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32 = std::move(value); }
+    inline void SetChecksumCRC32(const char* value) { m_checksumCRC32HasBeenSet = true; m_checksumCRC32.assign(value); }
+    inline CopyPartResult& WithChecksumCRC32(const Aws::String& value) { SetChecksumCRC32(value); return *this;}
+    inline CopyPartResult& WithChecksumCRC32(Aws::String&& value) { SetChecksumCRC32(std::move(value)); return *this;}
+    inline CopyPartResult& WithChecksumCRC32(const char* value) { SetChecksumCRC32(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 32-bit CRC-32C checksum of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumCRC32C() const{ return m_checksumCRC32C; }
+    inline bool ChecksumCRC32CHasBeenSet() const { return m_checksumCRC32CHasBeenSet; }
+    inline void SetChecksumCRC32C(const Aws::String& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = value; }
+    inline void SetChecksumCRC32C(Aws::String&& value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C = std::move(value); }
+    inline void SetChecksumCRC32C(const char* value) { m_checksumCRC32CHasBeenSet = true; m_checksumCRC32C.assign(value); }
+    inline CopyPartResult& WithChecksumCRC32C(const Aws::String& value) { SetChecksumCRC32C(value); return *this;}
+    inline CopyPartResult& WithChecksumCRC32C(Aws::String&& value) { SetChecksumCRC32C(std::move(value)); return *this;}
+    inline CopyPartResult& WithChecksumCRC32C(const char* value) { SetChecksumCRC32C(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 160-bit SHA-1 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use the API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA1() const{ return m_checksumSHA1; }
+    inline bool ChecksumSHA1HasBeenSet() const { return m_checksumSHA1HasBeenSet; }
+    inline void SetChecksumSHA1(const Aws::String& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = value; }
+    inline void SetChecksumSHA1(Aws::String&& value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1 = std::move(value); }
+    inline void SetChecksumSHA1(const char* value) { m_checksumSHA1HasBeenSet = true; m_checksumSHA1.assign(value); }
+    inline CopyPartResult& WithChecksumSHA1(const Aws::String& value) { SetChecksumSHA1(value); return *this;}
+    inline CopyPartResult& WithChecksumSHA1(Aws::String&& value) { SetChecksumSHA1(std::move(value)); return *this;}
+    inline CopyPartResult& WithChecksumSHA1(const char* value) { SetChecksumSHA1(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64-encoded, 256-bit SHA-256 digest of the object. This will only be
+     * present if it was uploaded with the object. When you use an API operation on an
+     * object that was uploaded using multipart uploads, this value may not be a direct
+     * checksum value of the full object. Instead, it's a calculation based on the
+     * checksum values of each individual part. For more information about how
+     * checksums are calculated with multipart uploads, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums">
+     * Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetChecksumSHA256() const{ return m_checksumSHA256; }
+    inline bool ChecksumSHA256HasBeenSet() const { return m_checksumSHA256HasBeenSet; }
+    inline void SetChecksumSHA256(const Aws::String& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = value; }
+    inline void SetChecksumSHA256(Aws::String&& value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256 = std::move(value); }
+    inline void SetChecksumSHA256(const char* value) { m_checksumSHA256HasBeenSet = true; m_checksumSHA256.assign(value); }
+    inline CopyPartResult& WithChecksumSHA256(const Aws::String& value) { SetChecksumSHA256(value); return *this;}
+    inline CopyPartResult& WithChecksumSHA256(Aws::String&& value) { SetChecksumSHA256(std::move(value)); return *this;}
+    inline CopyPartResult& WithChecksumSHA256(const char* value) { SetChecksumSHA256(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_eTag;
+    bool m_eTagHasBeenSet = false;
+
+    Aws::Utils::DateTime m_lastModified;
+    bool m_lastModifiedHasBeenSet = false;
+
+    Aws::String m_checksumCRC32;
+    bool m_checksumCRC32HasBeenSet = false;
+
+    Aws::String m_checksumCRC32C;
+    bool m_checksumCRC32CHasBeenSet = false;
+
+    Aws::String m_checksumSHA1;
+    bool m_checksumSHA1HasBeenSet = false;
+
+    Aws::String m_checksumSHA256;
+    bool m_checksumSHA256HasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateBucketConfiguration.h

@@ -0,0 +1,102 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/BucketLocationConstraint.h>
+#include <aws/s3/model/LocationInfo.h>
+#include <aws/s3/model/BucketInfo.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>The configuration information for the bucket.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/CreateBucketConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class CreateBucketConfiguration
+  {
+  public:
+    AWS_S3_API CreateBucketConfiguration();
+    AWS_S3_API CreateBucketConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API CreateBucketConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies the Region where the bucket will be created. You might choose a
+     * Region to optimize latency, minimize costs, or address regulatory requirements.
+     * For example, if you reside in Europe, you will probably find it advantageous to
+     * create buckets in the Europe (Ireland) Region. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro">Accessing
+     * a bucket</a> in the <i>Amazon S3 User Guide</i>.</p> <p>If you don't specify a
+     * Region, the bucket is created in the US East (N. Virginia) Region (us-east-1) by
+     * default.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const BucketLocationConstraint& GetLocationConstraint() const{ return m_locationConstraint; }
+    inline bool LocationConstraintHasBeenSet() const { return m_locationConstraintHasBeenSet; }
+    inline void SetLocationConstraint(const BucketLocationConstraint& value) { m_locationConstraintHasBeenSet = true; m_locationConstraint = value; }
+    inline void SetLocationConstraint(BucketLocationConstraint&& value) { m_locationConstraintHasBeenSet = true; m_locationConstraint = std::move(value); }
+    inline CreateBucketConfiguration& WithLocationConstraint(const BucketLocationConstraint& value) { SetLocationConstraint(value); return *this;}
+    inline CreateBucketConfiguration& WithLocationConstraint(BucketLocationConstraint&& value) { SetLocationConstraint(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the location where the bucket will be created.</p> <p>For directory
+     * buckets, the location type is Availability Zone.</p>  <p>This
+     * functionality is only supported by directory buckets.</p> 
+     */
+    inline const LocationInfo& GetLocation() const{ return m_location; }
+    inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
+    inline void SetLocation(const LocationInfo& value) { m_locationHasBeenSet = true; m_location = value; }
+    inline void SetLocation(LocationInfo&& value) { m_locationHasBeenSet = true; m_location = std::move(value); }
+    inline CreateBucketConfiguration& WithLocation(const LocationInfo& value) { SetLocation(value); return *this;}
+    inline CreateBucketConfiguration& WithLocation(LocationInfo&& value) { SetLocation(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the information about the bucket that will be created.</p> 
+     * <p>This functionality is only supported by directory buckets.</p> 
+     */
+    inline const BucketInfo& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const BucketInfo& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(BucketInfo&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline CreateBucketConfiguration& WithBucket(const BucketInfo& value) { SetBucket(value); return *this;}
+    inline CreateBucketConfiguration& WithBucket(BucketInfo&& value) { SetBucket(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    BucketLocationConstraint m_locationConstraint;
+    bool m_locationConstraintHasBeenSet = false;
+
+    LocationInfo m_location;
+    bool m_locationHasBeenSet = false;
+
+    BucketInfo m_bucket;
+    bool m_bucketHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateBucketRequest.h

@@ -0,0 +1,258 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/s3/model/BucketCannedACL.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/CreateBucketConfiguration.h>
+#include <aws/s3/model/ObjectOwnership.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class CreateBucketRequest : public S3Request
+  {
+  public:
+    AWS_S3_API CreateBucketRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateBucket"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The canned ACL to apply to the bucket.</p>  <p>This functionality is
+     * not supported for directory buckets.</p> 
+     */
+    inline const BucketCannedACL& GetACL() const{ return m_aCL; }
+    inline bool ACLHasBeenSet() const { return m_aCLHasBeenSet; }
+    inline void SetACL(const BucketCannedACL& value) { m_aCLHasBeenSet = true; m_aCL = value; }
+    inline void SetACL(BucketCannedACL&& value) { m_aCLHasBeenSet = true; m_aCL = std::move(value); }
+    inline CreateBucketRequest& WithACL(const BucketCannedACL& value) { SetACL(value); return *this;}
+    inline CreateBucketRequest& WithACL(BucketCannedACL&& value) { SetACL(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The name of the bucket to create.</p> <p> <b>General purpose buckets</b> -
+     * For information about bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html">Bucket
+     * naming rules</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Directory
+     * buckets </b> - When you use this operation with a directory bucket, you must use
+     * path-style requests in the format
+     * <code>https://s3express-control.<i>region_code</i>.amazonaws.com/<i>bucket-name</i>
+     * </code>. Virtual-hosted-style requests aren't supported. Directory bucket names
+     * must be unique in the chosen Availability Zone. Bucket names must also follow
+     * the format <code> <i>bucket_base_name</i>--<i>az_id</i>--x-s3</code> (for
+     * example, <code> <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For
+     * information about bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i> </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline CreateBucketRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline CreateBucketRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline CreateBucketRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The configuration information for the bucket.</p>
+     */
+    inline const CreateBucketConfiguration& GetCreateBucketConfiguration() const{ return m_createBucketConfiguration; }
+    inline bool CreateBucketConfigurationHasBeenSet() const { return m_createBucketConfigurationHasBeenSet; }
+    inline void SetCreateBucketConfiguration(const CreateBucketConfiguration& value) { m_createBucketConfigurationHasBeenSet = true; m_createBucketConfiguration = value; }
+    inline void SetCreateBucketConfiguration(CreateBucketConfiguration&& value) { m_createBucketConfigurationHasBeenSet = true; m_createBucketConfiguration = std::move(value); }
+    inline CreateBucketRequest& WithCreateBucketConfiguration(const CreateBucketConfiguration& value) { SetCreateBucketConfiguration(value); return *this;}
+    inline CreateBucketRequest& WithCreateBucketConfiguration(CreateBucketConfiguration&& value) { SetCreateBucketConfiguration(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Allows grantee the read, write, read ACP, and write ACP permissions on the
+     * bucket.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetGrantFullControl() const{ return m_grantFullControl; }
+    inline bool GrantFullControlHasBeenSet() const { return m_grantFullControlHasBeenSet; }
+    inline void SetGrantFullControl(const Aws::String& value) { m_grantFullControlHasBeenSet = true; m_grantFullControl = value; }
+    inline void SetGrantFullControl(Aws::String&& value) { m_grantFullControlHasBeenSet = true; m_grantFullControl = std::move(value); }
+    inline void SetGrantFullControl(const char* value) { m_grantFullControlHasBeenSet = true; m_grantFullControl.assign(value); }
+    inline CreateBucketRequest& WithGrantFullControl(const Aws::String& value) { SetGrantFullControl(value); return *this;}
+    inline CreateBucketRequest& WithGrantFullControl(Aws::String&& value) { SetGrantFullControl(std::move(value)); return *this;}
+    inline CreateBucketRequest& WithGrantFullControl(const char* value) { SetGrantFullControl(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Allows grantee to list the objects in the bucket.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetGrantRead() const{ return m_grantRead; }
+    inline bool GrantReadHasBeenSet() const { return m_grantReadHasBeenSet; }
+    inline void SetGrantRead(const Aws::String& value) { m_grantReadHasBeenSet = true; m_grantRead = value; }
+    inline void SetGrantRead(Aws::String&& value) { m_grantReadHasBeenSet = true; m_grantRead = std::move(value); }
+    inline void SetGrantRead(const char* value) { m_grantReadHasBeenSet = true; m_grantRead.assign(value); }
+    inline CreateBucketRequest& WithGrantRead(const Aws::String& value) { SetGrantRead(value); return *this;}
+    inline CreateBucketRequest& WithGrantRead(Aws::String&& value) { SetGrantRead(std::move(value)); return *this;}
+    inline CreateBucketRequest& WithGrantRead(const char* value) { SetGrantRead(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Allows grantee to read the bucket ACL.</p>  <p>This functionality is
+     * not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetGrantReadACP() const{ return m_grantReadACP; }
+    inline bool GrantReadACPHasBeenSet() const { return m_grantReadACPHasBeenSet; }
+    inline void SetGrantReadACP(const Aws::String& value) { m_grantReadACPHasBeenSet = true; m_grantReadACP = value; }
+    inline void SetGrantReadACP(Aws::String&& value) { m_grantReadACPHasBeenSet = true; m_grantReadACP = std::move(value); }
+    inline void SetGrantReadACP(const char* value) { m_grantReadACPHasBeenSet = true; m_grantReadACP.assign(value); }
+    inline CreateBucketRequest& WithGrantReadACP(const Aws::String& value) { SetGrantReadACP(value); return *this;}
+    inline CreateBucketRequest& WithGrantReadACP(Aws::String&& value) { SetGrantReadACP(std::move(value)); return *this;}
+    inline CreateBucketRequest& WithGrantReadACP(const char* value) { SetGrantReadACP(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Allows grantee to create new objects in the bucket.</p> <p>For the bucket and
+     * object owners of existing objects, also allows deletions and overwrites of those
+     * objects.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetGrantWrite() const{ return m_grantWrite; }
+    inline bool GrantWriteHasBeenSet() const { return m_grantWriteHasBeenSet; }
+    inline void SetGrantWrite(const Aws::String& value) { m_grantWriteHasBeenSet = true; m_grantWrite = value; }
+    inline void SetGrantWrite(Aws::String&& value) { m_grantWriteHasBeenSet = true; m_grantWrite = std::move(value); }
+    inline void SetGrantWrite(const char* value) { m_grantWriteHasBeenSet = true; m_grantWrite.assign(value); }
+    inline CreateBucketRequest& WithGrantWrite(const Aws::String& value) { SetGrantWrite(value); return *this;}
+    inline CreateBucketRequest& WithGrantWrite(Aws::String&& value) { SetGrantWrite(std::move(value)); return *this;}
+    inline CreateBucketRequest& WithGrantWrite(const char* value) { SetGrantWrite(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Allows grantee to write the ACL for the applicable bucket.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetGrantWriteACP() const{ return m_grantWriteACP; }
+    inline bool GrantWriteACPHasBeenSet() const { return m_grantWriteACPHasBeenSet; }
+    inline void SetGrantWriteACP(const Aws::String& value) { m_grantWriteACPHasBeenSet = true; m_grantWriteACP = value; }
+    inline void SetGrantWriteACP(Aws::String&& value) { m_grantWriteACPHasBeenSet = true; m_grantWriteACP = std::move(value); }
+    inline void SetGrantWriteACP(const char* value) { m_grantWriteACPHasBeenSet = true; m_grantWriteACP.assign(value); }
+    inline CreateBucketRequest& WithGrantWriteACP(const Aws::String& value) { SetGrantWriteACP(value); return *this;}
+    inline CreateBucketRequest& WithGrantWriteACP(Aws::String&& value) { SetGrantWriteACP(std::move(value)); return *this;}
+    inline CreateBucketRequest& WithGrantWriteACP(const char* value) { SetGrantWriteACP(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies whether you want S3 Object Lock to be enabled for the new
+     * bucket.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline bool GetObjectLockEnabledForBucket() const{ return m_objectLockEnabledForBucket; }
+    inline bool ObjectLockEnabledForBucketHasBeenSet() const { return m_objectLockEnabledForBucketHasBeenSet; }
+    inline void SetObjectLockEnabledForBucket(bool value) { m_objectLockEnabledForBucketHasBeenSet = true; m_objectLockEnabledForBucket = value; }
+    inline CreateBucketRequest& WithObjectLockEnabledForBucket(bool value) { SetObjectLockEnabledForBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ObjectOwnership& GetObjectOwnership() const{ return m_objectOwnership; }
+    inline bool ObjectOwnershipHasBeenSet() const { return m_objectOwnershipHasBeenSet; }
+    inline void SetObjectOwnership(const ObjectOwnership& value) { m_objectOwnershipHasBeenSet = true; m_objectOwnership = value; }
+    inline void SetObjectOwnership(ObjectOwnership&& value) { m_objectOwnershipHasBeenSet = true; m_objectOwnership = std::move(value); }
+    inline CreateBucketRequest& WithObjectOwnership(const ObjectOwnership& value) { SetObjectOwnership(value); return *this;}
+    inline CreateBucketRequest& WithObjectOwnership(ObjectOwnership&& value) { SetObjectOwnership(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline CreateBucketRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline CreateBucketRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CreateBucketRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    BucketCannedACL m_aCL;
+    bool m_aCLHasBeenSet = false;
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    CreateBucketConfiguration m_createBucketConfiguration;
+    bool m_createBucketConfigurationHasBeenSet = false;
+
+    Aws::String m_grantFullControl;
+    bool m_grantFullControlHasBeenSet = false;
+
+    Aws::String m_grantRead;
+    bool m_grantReadHasBeenSet = false;
+
+    Aws::String m_grantReadACP;
+    bool m_grantReadACPHasBeenSet = false;
+
+    Aws::String m_grantWrite;
+    bool m_grantWriteHasBeenSet = false;
+
+    Aws::String m_grantWriteACP;
+    bool m_grantWriteACPHasBeenSet = false;
+
+    bool m_objectLockEnabledForBucket;
+    bool m_objectLockEnabledForBucketHasBeenSet = false;
+
+    ObjectOwnership m_objectOwnership;
+    bool m_objectOwnershipHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateBucketResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class CreateBucketResult
+  {
+  public:
+    AWS_S3_API CreateBucketResult();
+    AWS_S3_API CreateBucketResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API CreateBucketResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>A forward slash followed by the name of the bucket.</p>
+     */
+    inline const Aws::String& GetLocation() const{ return m_location; }
+    inline void SetLocation(const Aws::String& value) { m_location = value; }
+    inline void SetLocation(Aws::String&& value) { m_location = std::move(value); }
+    inline void SetLocation(const char* value) { m_location.assign(value); }
+    inline CreateBucketResult& WithLocation(const Aws::String& value) { SetLocation(value); return *this;}
+    inline CreateBucketResult& WithLocation(Aws::String&& value) { SetLocation(std::move(value)); return *this;}
+    inline CreateBucketResult& WithLocation(const char* value) { SetLocation(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline CreateBucketResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline CreateBucketResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline CreateBucketResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_location;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateMultipartUploadRequest.h

@@ -0,0 +1,860 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/s3/model/ObjectCannedACL.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/s3/model/StorageClass.h>
+#include <aws/s3/model/RequestPayer.h>
+#include <aws/s3/model/ObjectLockMode.h>
+#include <aws/s3/model/ObjectLockLegalHoldStatus.h>
+#include <aws/s3/model/ChecksumAlgorithm.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class CreateMultipartUploadRequest : public S3Request
+  {
+  public:
+    AWS_S3_API CreateMultipartUploadRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateMultipartUpload"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The canned ACL to apply to the object. Amazon S3 supports a set of predefined
+     * ACLs, known as <i>canned ACLs</i>. Each canned ACL has a predefined set of
+     * grantees and permissions. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#CannedACL">Canned
+     * ACL</a> in the <i>Amazon S3 User Guide</i>.</p> <p>By default, all objects are
+     * private. Only the owner has full access control. When uploading an object, you
+     * can grant access permissions to individual Amazon Web Services accounts or to
+     * predefined groups defined by Amazon S3. These permissions are then added to the
+     * access control list (ACL) on the new object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/S3_ACLs_UsingACLs.html">Using
+     * ACLs</a>. One way to grant the permissions using the request headers is to
+     * specify a canned ACL with the <code>x-amz-acl</code> request header.</p> 
+     * <ul> <li> <p>This functionality is not supported for directory buckets.</p>
+     * </li> <li> <p>This functionality is not supported for Amazon S3 on Outposts.</p>
+     * </li> </ul> 
+     */
+    inline const ObjectCannedACL& GetACL() const{ return m_aCL; }
+    inline bool ACLHasBeenSet() const { return m_aCLHasBeenSet; }
+    inline void SetACL(const ObjectCannedACL& value) { m_aCLHasBeenSet = true; m_aCL = value; }
+    inline void SetACL(ObjectCannedACL&& value) { m_aCLHasBeenSet = true; m_aCL = std::move(value); }
+    inline CreateMultipartUploadRequest& WithACL(const ObjectCannedACL& value) { SetACL(value); return *this;}
+    inline CreateMultipartUploadRequest& WithACL(ObjectCannedACL&& value) { SetACL(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The name of the bucket where the multipart upload is initiated and where the
+     * object is uploaded.</p> <p> <b>Directory buckets</b> - When you use this
+     * operation with a directory bucket, you must use virtual-hosted-style requests in
+     * the format <code>
+     * <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>.
+     * Path-style requests are not supported. Directory bucket names must be unique in
+     * the chosen Availability Zone. Bucket names must follow the format <code>
+     * <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>
+     * <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about
+     * bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Access
+     * points</b> - When you use this action with an access point, you must provide the
+     * alias of the access point in place of the bucket name or specify the access
+     * point ARN. When using the access point ARN, you must direct requests to the
+     * access point hostname. The access point hostname takes the form
+     * <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com.
+     * When using this action with an access point through the Amazon Web Services
+     * SDKs, you provide the access point ARN in place of the bucket name. For more
+     * information about access point ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using
+     * access points</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>Access
+     * points and Object Lambda access points are not supported by directory
+     * buckets.</p>  <p> <b>S3 on Outposts</b> - When you use this action with
+     * Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname.
+     * The S3 on Outposts hostname takes the form <code>
+     * <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>.
+     * When you use this action with S3 on Outposts through the Amazon Web Services
+     * SDKs, you provide the Outposts access point ARN in place of the bucket name. For
+     * more information about S3 on Outposts ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What
+     * is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline CreateMultipartUploadRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline CreateMultipartUploadRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies caching behavior along the request/reply chain.</p>
+     */
+    inline const Aws::String& GetCacheControl() const{ return m_cacheControl; }
+    inline bool CacheControlHasBeenSet() const { return m_cacheControlHasBeenSet; }
+    inline void SetCacheControl(const Aws::String& value) { m_cacheControlHasBeenSet = true; m_cacheControl = value; }
+    inline void SetCacheControl(Aws::String&& value) { m_cacheControlHasBeenSet = true; m_cacheControl = std::move(value); }
+    inline void SetCacheControl(const char* value) { m_cacheControlHasBeenSet = true; m_cacheControl.assign(value); }
+    inline CreateMultipartUploadRequest& WithCacheControl(const Aws::String& value) { SetCacheControl(value); return *this;}
+    inline CreateMultipartUploadRequest& WithCacheControl(Aws::String&& value) { SetCacheControl(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithCacheControl(const char* value) { SetCacheControl(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies presentational information for the object.</p>
+     */
+    inline const Aws::String& GetContentDisposition() const{ return m_contentDisposition; }
+    inline bool ContentDispositionHasBeenSet() const { return m_contentDispositionHasBeenSet; }
+    inline void SetContentDisposition(const Aws::String& value) { m_contentDispositionHasBeenSet = true; m_contentDisposition = value; }
+    inline void SetContentDisposition(Aws::String&& value) { m_contentDispositionHasBeenSet = true; m_contentDisposition = std::move(value); }
+    inline void SetContentDisposition(const char* value) { m_contentDispositionHasBeenSet = true; m_contentDisposition.assign(value); }
+    inline CreateMultipartUploadRequest& WithContentDisposition(const Aws::String& value) { SetContentDisposition(value); return *this;}
+    inline CreateMultipartUploadRequest& WithContentDisposition(Aws::String&& value) { SetContentDisposition(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithContentDisposition(const char* value) { SetContentDisposition(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies what content encodings have been applied to the object and thus
+     * what decoding mechanisms must be applied to obtain the media-type referenced by
+     * the Content-Type header field.</p>  <p>For directory buckets, only the
+     * <code>aws-chunked</code> value is supported in this header field.</p> 
+     */
+    inline const Aws::String& GetContentEncoding() const{ return m_contentEncoding; }
+    inline bool ContentEncodingHasBeenSet() const { return m_contentEncodingHasBeenSet; }
+    inline void SetContentEncoding(const Aws::String& value) { m_contentEncodingHasBeenSet = true; m_contentEncoding = value; }
+    inline void SetContentEncoding(Aws::String&& value) { m_contentEncodingHasBeenSet = true; m_contentEncoding = std::move(value); }
+    inline void SetContentEncoding(const char* value) { m_contentEncodingHasBeenSet = true; m_contentEncoding.assign(value); }
+    inline CreateMultipartUploadRequest& WithContentEncoding(const Aws::String& value) { SetContentEncoding(value); return *this;}
+    inline CreateMultipartUploadRequest& WithContentEncoding(Aws::String&& value) { SetContentEncoding(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithContentEncoding(const char* value) { SetContentEncoding(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The language that the content is in.</p>
+     */
+    inline const Aws::String& GetContentLanguage() const{ return m_contentLanguage; }
+    inline bool ContentLanguageHasBeenSet() const { return m_contentLanguageHasBeenSet; }
+    inline void SetContentLanguage(const Aws::String& value) { m_contentLanguageHasBeenSet = true; m_contentLanguage = value; }
+    inline void SetContentLanguage(Aws::String&& value) { m_contentLanguageHasBeenSet = true; m_contentLanguage = std::move(value); }
+    inline void SetContentLanguage(const char* value) { m_contentLanguageHasBeenSet = true; m_contentLanguage.assign(value); }
+    inline CreateMultipartUploadRequest& WithContentLanguage(const Aws::String& value) { SetContentLanguage(value); return *this;}
+    inline CreateMultipartUploadRequest& WithContentLanguage(Aws::String&& value) { SetContentLanguage(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithContentLanguage(const char* value) { SetContentLanguage(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A standard MIME type describing the format of the object data.</p>
+     */
+    inline const Aws::String& GetContentType() const{ return m_contentType; }
+    inline bool ContentTypeHasBeenSet() const { return m_contentTypeHasBeenSet; }
+    inline void SetContentType(const Aws::String& value) { m_contentTypeHasBeenSet = true; m_contentType = value; }
+    inline void SetContentType(Aws::String&& value) { m_contentTypeHasBeenSet = true; m_contentType = std::move(value); }
+    inline void SetContentType(const char* value) { m_contentTypeHasBeenSet = true; m_contentType.assign(value); }
+    inline CreateMultipartUploadRequest& WithContentType(const Aws::String& value) { SetContentType(value); return *this;}
+    inline CreateMultipartUploadRequest& WithContentType(Aws::String&& value) { SetContentType(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithContentType(const char* value) { SetContentType(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The date and time at which the object is no longer cacheable.</p>
+     */
+    inline const Aws::Utils::DateTime& GetExpires() const{ return m_expires; }
+    inline bool ExpiresHasBeenSet() const { return m_expiresHasBeenSet; }
+    inline void SetExpires(const Aws::Utils::DateTime& value) { m_expiresHasBeenSet = true; m_expires = value; }
+    inline void SetExpires(Aws::Utils::DateTime&& value) { m_expiresHasBeenSet = true; m_expires = std::move(value); }
+    inline CreateMultipartUploadRequest& WithExpires(const Aws::Utils::DateTime& value) { SetExpires(value); return *this;}
+    inline CreateMultipartUploadRequest& WithExpires(Aws::Utils::DateTime&& value) { SetExpires(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specify access permissions explicitly to give the grantee READ, READ_ACP, and
+     * WRITE_ACP permissions on the object.</p> <p>By default, all objects are private.
+     * Only the owner has full access control. When uploading an object, you can use
+     * this header to explicitly grant access permissions to specific Amazon Web
+     * Services accounts or groups. This header maps to specific permissions that
+     * Amazon S3 supports in an ACL. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html">Access
+     * Control List (ACL) Overview</a> in the <i>Amazon S3 User Guide</i>.</p> <p>You
+     * specify each grantee as a type=value pair, where the type is one of the
+     * following:</p> <ul> <li> <p> <code>id</code> – if the value specified is the
+     * canonical user ID of an Amazon Web Services account</p> </li> <li> <p>
+     * <code>uri</code> – if you are granting permissions to a predefined group</p>
+     * </li> <li> <p> <code>emailAddress</code> – if the value specified is the email
+     * address of an Amazon Web Services account</p>  <p>Using email addresses to
+     * specify a grantee is only supported in the following Amazon Web Services
+     * Regions: </p> <ul> <li> <p>US East (N. Virginia)</p> </li> <li> <p>US West (N.
+     * California)</p> </li> <li> <p> US West (Oregon)</p> </li> <li> <p> Asia Pacific
+     * (Singapore)</p> </li> <li> <p>Asia Pacific (Sydney)</p> </li> <li> <p>Asia
+     * Pacific (Tokyo)</p> </li> <li> <p>Europe (Ireland)</p> </li> <li> <p>South
+     * America (São Paulo)</p> </li> </ul> <p>For a list of all the Amazon S3 supported
+     * Regions and endpoints, see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions
+     * and Endpoints</a> in the Amazon Web Services General Reference.</p> 
+     * </li> </ul> <p>For example, the following <code>x-amz-grant-read</code> header
+     * grants the Amazon Web Services accounts identified by account IDs permissions to
+     * read object data and its metadata:</p> <p> <code>x-amz-grant-read:
+     * id="11112222333", id="444455556666" </code> </p>  <ul> <li> <p>This
+     * functionality is not supported for directory buckets.</p> </li> <li> <p>This
+     * functionality is not supported for Amazon S3 on Outposts.</p> </li> </ul>
+     * 
+     */
+    inline const Aws::String& GetGrantFullControl() const{ return m_grantFullControl; }
+    inline bool GrantFullControlHasBeenSet() const { return m_grantFullControlHasBeenSet; }
+    inline void SetGrantFullControl(const Aws::String& value) { m_grantFullControlHasBeenSet = true; m_grantFullControl = value; }
+    inline void SetGrantFullControl(Aws::String&& value) { m_grantFullControlHasBeenSet = true; m_grantFullControl = std::move(value); }
+    inline void SetGrantFullControl(const char* value) { m_grantFullControlHasBeenSet = true; m_grantFullControl.assign(value); }
+    inline CreateMultipartUploadRequest& WithGrantFullControl(const Aws::String& value) { SetGrantFullControl(value); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantFullControl(Aws::String&& value) { SetGrantFullControl(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantFullControl(const char* value) { SetGrantFullControl(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specify access permissions explicitly to allow grantee to read the object
+     * data and its metadata.</p> <p>By default, all objects are private. Only the
+     * owner has full access control. When uploading an object, you can use this header
+     * to explicitly grant access permissions to specific Amazon Web Services accounts
+     * or groups. This header maps to specific permissions that Amazon S3 supports in
+     * an ACL. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html">Access
+     * Control List (ACL) Overview</a> in the <i>Amazon S3 User Guide</i>.</p> <p>You
+     * specify each grantee as a type=value pair, where the type is one of the
+     * following:</p> <ul> <li> <p> <code>id</code> – if the value specified is the
+     * canonical user ID of an Amazon Web Services account</p> </li> <li> <p>
+     * <code>uri</code> – if you are granting permissions to a predefined group</p>
+     * </li> <li> <p> <code>emailAddress</code> – if the value specified is the email
+     * address of an Amazon Web Services account</p>  <p>Using email addresses to
+     * specify a grantee is only supported in the following Amazon Web Services
+     * Regions: </p> <ul> <li> <p>US East (N. Virginia)</p> </li> <li> <p>US West (N.
+     * California)</p> </li> <li> <p> US West (Oregon)</p> </li> <li> <p> Asia Pacific
+     * (Singapore)</p> </li> <li> <p>Asia Pacific (Sydney)</p> </li> <li> <p>Asia
+     * Pacific (Tokyo)</p> </li> <li> <p>Europe (Ireland)</p> </li> <li> <p>South
+     * America (São Paulo)</p> </li> </ul> <p>For a list of all the Amazon S3 supported
+     * Regions and endpoints, see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions
+     * and Endpoints</a> in the Amazon Web Services General Reference.</p> 
+     * </li> </ul> <p>For example, the following <code>x-amz-grant-read</code> header
+     * grants the Amazon Web Services accounts identified by account IDs permissions to
+     * read object data and its metadata:</p> <p> <code>x-amz-grant-read:
+     * id="11112222333", id="444455556666" </code> </p>  <ul> <li> <p>This
+     * functionality is not supported for directory buckets.</p> </li> <li> <p>This
+     * functionality is not supported for Amazon S3 on Outposts.</p> </li> </ul>
+     * 
+     */
+    inline const Aws::String& GetGrantRead() const{ return m_grantRead; }
+    inline bool GrantReadHasBeenSet() const { return m_grantReadHasBeenSet; }
+    inline void SetGrantRead(const Aws::String& value) { m_grantReadHasBeenSet = true; m_grantRead = value; }
+    inline void SetGrantRead(Aws::String&& value) { m_grantReadHasBeenSet = true; m_grantRead = std::move(value); }
+    inline void SetGrantRead(const char* value) { m_grantReadHasBeenSet = true; m_grantRead.assign(value); }
+    inline CreateMultipartUploadRequest& WithGrantRead(const Aws::String& value) { SetGrantRead(value); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantRead(Aws::String&& value) { SetGrantRead(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantRead(const char* value) { SetGrantRead(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specify access permissions explicitly to allows grantee to read the object
+     * ACL.</p> <p>By default, all objects are private. Only the owner has full access
+     * control. When uploading an object, you can use this header to explicitly grant
+     * access permissions to specific Amazon Web Services accounts or groups. This
+     * header maps to specific permissions that Amazon S3 supports in an ACL. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html">Access
+     * Control List (ACL) Overview</a> in the <i>Amazon S3 User Guide</i>.</p> <p>You
+     * specify each grantee as a type=value pair, where the type is one of the
+     * following:</p> <ul> <li> <p> <code>id</code> – if the value specified is the
+     * canonical user ID of an Amazon Web Services account</p> </li> <li> <p>
+     * <code>uri</code> – if you are granting permissions to a predefined group</p>
+     * </li> <li> <p> <code>emailAddress</code> – if the value specified is the email
+     * address of an Amazon Web Services account</p>  <p>Using email addresses to
+     * specify a grantee is only supported in the following Amazon Web Services
+     * Regions: </p> <ul> <li> <p>US East (N. Virginia)</p> </li> <li> <p>US West (N.
+     * California)</p> </li> <li> <p> US West (Oregon)</p> </li> <li> <p> Asia Pacific
+     * (Singapore)</p> </li> <li> <p>Asia Pacific (Sydney)</p> </li> <li> <p>Asia
+     * Pacific (Tokyo)</p> </li> <li> <p>Europe (Ireland)</p> </li> <li> <p>South
+     * America (São Paulo)</p> </li> </ul> <p>For a list of all the Amazon S3 supported
+     * Regions and endpoints, see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions
+     * and Endpoints</a> in the Amazon Web Services General Reference.</p> 
+     * </li> </ul> <p>For example, the following <code>x-amz-grant-read</code> header
+     * grants the Amazon Web Services accounts identified by account IDs permissions to
+     * read object data and its metadata:</p> <p> <code>x-amz-grant-read:
+     * id="11112222333", id="444455556666" </code> </p>  <ul> <li> <p>This
+     * functionality is not supported for directory buckets.</p> </li> <li> <p>This
+     * functionality is not supported for Amazon S3 on Outposts.</p> </li> </ul>
+     * 
+     */
+    inline const Aws::String& GetGrantReadACP() const{ return m_grantReadACP; }
+    inline bool GrantReadACPHasBeenSet() const { return m_grantReadACPHasBeenSet; }
+    inline void SetGrantReadACP(const Aws::String& value) { m_grantReadACPHasBeenSet = true; m_grantReadACP = value; }
+    inline void SetGrantReadACP(Aws::String&& value) { m_grantReadACPHasBeenSet = true; m_grantReadACP = std::move(value); }
+    inline void SetGrantReadACP(const char* value) { m_grantReadACPHasBeenSet = true; m_grantReadACP.assign(value); }
+    inline CreateMultipartUploadRequest& WithGrantReadACP(const Aws::String& value) { SetGrantReadACP(value); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantReadACP(Aws::String&& value) { SetGrantReadACP(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantReadACP(const char* value) { SetGrantReadACP(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specify access permissions explicitly to allows grantee to allow grantee to
+     * write the ACL for the applicable object.</p> <p>By default, all objects are
+     * private. Only the owner has full access control. When uploading an object, you
+     * can use this header to explicitly grant access permissions to specific Amazon
+     * Web Services accounts or groups. This header maps to specific permissions that
+     * Amazon S3 supports in an ACL. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html">Access
+     * Control List (ACL) Overview</a> in the <i>Amazon S3 User Guide</i>.</p> <p>You
+     * specify each grantee as a type=value pair, where the type is one of the
+     * following:</p> <ul> <li> <p> <code>id</code> – if the value specified is the
+     * canonical user ID of an Amazon Web Services account</p> </li> <li> <p>
+     * <code>uri</code> – if you are granting permissions to a predefined group</p>
+     * </li> <li> <p> <code>emailAddress</code> – if the value specified is the email
+     * address of an Amazon Web Services account</p>  <p>Using email addresses to
+     * specify a grantee is only supported in the following Amazon Web Services
+     * Regions: </p> <ul> <li> <p>US East (N. Virginia)</p> </li> <li> <p>US West (N.
+     * California)</p> </li> <li> <p> US West (Oregon)</p> </li> <li> <p> Asia Pacific
+     * (Singapore)</p> </li> <li> <p>Asia Pacific (Sydney)</p> </li> <li> <p>Asia
+     * Pacific (Tokyo)</p> </li> <li> <p>Europe (Ireland)</p> </li> <li> <p>South
+     * America (São Paulo)</p> </li> </ul> <p>For a list of all the Amazon S3 supported
+     * Regions and endpoints, see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions
+     * and Endpoints</a> in the Amazon Web Services General Reference.</p> 
+     * </li> </ul> <p>For example, the following <code>x-amz-grant-read</code> header
+     * grants the Amazon Web Services accounts identified by account IDs permissions to
+     * read object data and its metadata:</p> <p> <code>x-amz-grant-read:
+     * id="11112222333", id="444455556666" </code> </p>  <ul> <li> <p>This
+     * functionality is not supported for directory buckets.</p> </li> <li> <p>This
+     * functionality is not supported for Amazon S3 on Outposts.</p> </li> </ul>
+     * 
+     */
+    inline const Aws::String& GetGrantWriteACP() const{ return m_grantWriteACP; }
+    inline bool GrantWriteACPHasBeenSet() const { return m_grantWriteACPHasBeenSet; }
+    inline void SetGrantWriteACP(const Aws::String& value) { m_grantWriteACPHasBeenSet = true; m_grantWriteACP = value; }
+    inline void SetGrantWriteACP(Aws::String&& value) { m_grantWriteACPHasBeenSet = true; m_grantWriteACP = std::move(value); }
+    inline void SetGrantWriteACP(const char* value) { m_grantWriteACPHasBeenSet = true; m_grantWriteACP.assign(value); }
+    inline CreateMultipartUploadRequest& WithGrantWriteACP(const Aws::String& value) { SetGrantWriteACP(value); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantWriteACP(Aws::String&& value) { SetGrantWriteACP(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithGrantWriteACP(const char* value) { SetGrantWriteACP(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Object key for which the multipart upload is to be initiated.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline CreateMultipartUploadRequest& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline CreateMultipartUploadRequest& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A map of metadata to store with the object in S3.</p>
+     */
+    inline const Aws::Map<Aws::String, Aws::String>& GetMetadata() const{ return m_metadata; }
+    inline bool MetadataHasBeenSet() const { return m_metadataHasBeenSet; }
+    inline void SetMetadata(const Aws::Map<Aws::String, Aws::String>& value) { m_metadataHasBeenSet = true; m_metadata = value; }
+    inline void SetMetadata(Aws::Map<Aws::String, Aws::String>&& value) { m_metadataHasBeenSet = true; m_metadata = std::move(value); }
+    inline CreateMultipartUploadRequest& WithMetadata(const Aws::Map<Aws::String, Aws::String>& value) { SetMetadata(value); return *this;}
+    inline CreateMultipartUploadRequest& WithMetadata(Aws::Map<Aws::String, Aws::String>&& value) { SetMetadata(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& AddMetadata(const Aws::String& key, const Aws::String& value) { m_metadataHasBeenSet = true; m_metadata.emplace(key, value); return *this; }
+    inline CreateMultipartUploadRequest& AddMetadata(Aws::String&& key, const Aws::String& value) { m_metadataHasBeenSet = true; m_metadata.emplace(std::move(key), value); return *this; }
+    inline CreateMultipartUploadRequest& AddMetadata(const Aws::String& key, Aws::String&& value) { m_metadataHasBeenSet = true; m_metadata.emplace(key, std::move(value)); return *this; }
+    inline CreateMultipartUploadRequest& AddMetadata(Aws::String&& key, Aws::String&& value) { m_metadataHasBeenSet = true; m_metadata.emplace(std::move(key), std::move(value)); return *this; }
+    inline CreateMultipartUploadRequest& AddMetadata(const char* key, Aws::String&& value) { m_metadataHasBeenSet = true; m_metadata.emplace(key, std::move(value)); return *this; }
+    inline CreateMultipartUploadRequest& AddMetadata(Aws::String&& key, const char* value) { m_metadataHasBeenSet = true; m_metadata.emplace(std::move(key), value); return *this; }
+    inline CreateMultipartUploadRequest& AddMetadata(const char* key, const char* value) { m_metadataHasBeenSet = true; m_metadata.emplace(key, value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm used when you store this object in
+     * Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>).</p> <ul>
+     * <li> <p> <b>Directory buckets </b> - For directory buckets, there are only two
+     * supported options for server-side encryption: server-side encryption with Amazon
+     * S3 managed keys (SSE-S3) (<code>AES256</code>) and server-side encryption with
+     * KMS keys (SSE-KMS) (<code>aws:kms</code>). We recommend that the bucket's
+     * default encryption uses the desired encryption configuration and you don't
+     * override the bucket default encryption in your <code>CreateSession</code>
+     * requests or <code>PUT</code> object requests. Then, new objects are
+     * automatically encrypted with the desired encryption settings. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-serv-side-encryption.html">Protecting
+     * data with server-side encryption</a> in the <i>Amazon S3 User Guide</i>. For
+     * more information about the encryption overriding behaviors in directory buckets,
+     * see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying
+     * server-side encryption with KMS for new object uploads</a>. </p> <p>In the Zonal
+     * endpoint API calls (except <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>
+     * and <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>)
+     * using the REST API, the encryption request headers must match the encryption
+     * settings that are specified in the <code>CreateSession</code> request. You can't
+     * override the values of the encryption settings
+     * (<code>x-amz-server-side-encryption</code>,
+     * <code>x-amz-server-side-encryption-aws-kms-key-id</code>,
+     * <code>x-amz-server-side-encryption-context</code>, and
+     * <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified
+     * in the <code>CreateSession</code> request. You don't need to explicitly specify
+     * these encryption settings values in Zonal endpoint API calls, and Amazon S3 will
+     * use the encryption settings values from the <code>CreateSession</code> request
+     * to protect new objects in the directory bucket. </p>  <p>When you use the
+     * CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session
+     * token refreshes automatically to avoid service interruptions when a session
+     * expires. The CLI or the Amazon Web Services SDKs use the bucket's default
+     * encryption configuration for the <code>CreateSession</code> request. It's not
+     * supported to override the encryption settings values in the
+     * <code>CreateSession</code> request. So in the Zonal endpoint API calls (except
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>
+     * and <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>),
+     * the encryption request headers must match the default encryption configuration
+     * of the directory bucket. </p>  </li> </ul>
+     */
+    inline const ServerSideEncryption& GetServerSideEncryption() const{ return m_serverSideEncryption; }
+    inline bool ServerSideEncryptionHasBeenSet() const { return m_serverSideEncryptionHasBeenSet; }
+    inline void SetServerSideEncryption(const ServerSideEncryption& value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption = value; }
+    inline void SetServerSideEncryption(ServerSideEncryption&& value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption = std::move(value); }
+    inline CreateMultipartUploadRequest& WithServerSideEncryption(const ServerSideEncryption& value) { SetServerSideEncryption(value); return *this;}
+    inline CreateMultipartUploadRequest& WithServerSideEncryption(ServerSideEncryption&& value) { SetServerSideEncryption(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>By default, Amazon S3 uses the STANDARD Storage Class to store newly created
+     * objects. The STANDARD storage class provides high durability and high
+     * availability. Depending on performance needs, you can specify a different
+     * Storage Class. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html">Storage
+     * Classes</a> in the <i>Amazon S3 User Guide</i>.</p>  <ul> <li> <p>For
+     * directory buckets, only the S3 Express One Zone storage class is supported to
+     * store newly created objects.</p> </li> <li> <p>Amazon S3 on Outposts only uses
+     * the OUTPOSTS Storage Class.</p> </li> </ul> 
+     */
+    inline const StorageClass& GetStorageClass() const{ return m_storageClass; }
+    inline bool StorageClassHasBeenSet() const { return m_storageClassHasBeenSet; }
+    inline void SetStorageClass(const StorageClass& value) { m_storageClassHasBeenSet = true; m_storageClass = value; }
+    inline void SetStorageClass(StorageClass&& value) { m_storageClassHasBeenSet = true; m_storageClass = std::move(value); }
+    inline CreateMultipartUploadRequest& WithStorageClass(const StorageClass& value) { SetStorageClass(value); return *this;}
+    inline CreateMultipartUploadRequest& WithStorageClass(StorageClass&& value) { SetStorageClass(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If the bucket is configured as a website, redirects requests for this object
+     * to another object in the same bucket or to an external URL. Amazon S3 stores the
+     * value of this header in the object metadata.</p>  <p>This functionality is
+     * not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetWebsiteRedirectLocation() const{ return m_websiteRedirectLocation; }
+    inline bool WebsiteRedirectLocationHasBeenSet() const { return m_websiteRedirectLocationHasBeenSet; }
+    inline void SetWebsiteRedirectLocation(const Aws::String& value) { m_websiteRedirectLocationHasBeenSet = true; m_websiteRedirectLocation = value; }
+    inline void SetWebsiteRedirectLocation(Aws::String&& value) { m_websiteRedirectLocationHasBeenSet = true; m_websiteRedirectLocation = std::move(value); }
+    inline void SetWebsiteRedirectLocation(const char* value) { m_websiteRedirectLocationHasBeenSet = true; m_websiteRedirectLocation.assign(value); }
+    inline CreateMultipartUploadRequest& WithWebsiteRedirectLocation(const Aws::String& value) { SetWebsiteRedirectLocation(value); return *this;}
+    inline CreateMultipartUploadRequest& WithWebsiteRedirectLocation(Aws::String&& value) { SetWebsiteRedirectLocation(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithWebsiteRedirectLocation(const char* value) { SetWebsiteRedirectLocation(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the algorithm to use when encrypting the object (for example,
+     * AES256).</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerAlgorithm() const{ return m_sSECustomerAlgorithm; }
+    inline bool SSECustomerAlgorithmHasBeenSet() const { return m_sSECustomerAlgorithmHasBeenSet; }
+    inline void SetSSECustomerAlgorithm(const Aws::String& value) { m_sSECustomerAlgorithmHasBeenSet = true; m_sSECustomerAlgorithm = value; }
+    inline void SetSSECustomerAlgorithm(Aws::String&& value) { m_sSECustomerAlgorithmHasBeenSet = true; m_sSECustomerAlgorithm = std::move(value); }
+    inline void SetSSECustomerAlgorithm(const char* value) { m_sSECustomerAlgorithmHasBeenSet = true; m_sSECustomerAlgorithm.assign(value); }
+    inline CreateMultipartUploadRequest& WithSSECustomerAlgorithm(const Aws::String& value) { SetSSECustomerAlgorithm(value); return *this;}
+    inline CreateMultipartUploadRequest& WithSSECustomerAlgorithm(Aws::String&& value) { SetSSECustomerAlgorithm(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithSSECustomerAlgorithm(const char* value) { SetSSECustomerAlgorithm(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the customer-provided encryption key for Amazon S3 to use in
+     * encrypting data. This value is used to store the object and then it is
+     * discarded; Amazon S3 does not store the encryption key. The key must be
+     * appropriate for use with the algorithm specified in the
+     * <code>x-amz-server-side-encryption-customer-algorithm</code> header.</p> 
+     * <p>This functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerKey() const{ return m_sSECustomerKey; }
+    inline bool SSECustomerKeyHasBeenSet() const { return m_sSECustomerKeyHasBeenSet; }
+    inline void SetSSECustomerKey(const Aws::String& value) { m_sSECustomerKeyHasBeenSet = true; m_sSECustomerKey = value; }
+    inline void SetSSECustomerKey(Aws::String&& value) { m_sSECustomerKeyHasBeenSet = true; m_sSECustomerKey = std::move(value); }
+    inline void SetSSECustomerKey(const char* value) { m_sSECustomerKeyHasBeenSet = true; m_sSECustomerKey.assign(value); }
+    inline CreateMultipartUploadRequest& WithSSECustomerKey(const Aws::String& value) { SetSSECustomerKey(value); return *this;}
+    inline CreateMultipartUploadRequest& WithSSECustomerKey(Aws::String&& value) { SetSSECustomerKey(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithSSECustomerKey(const char* value) { SetSSECustomerKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the 128-bit MD5 digest of the customer-provided encryption key
+     * according to RFC 1321. Amazon S3 uses this header for a message integrity check
+     * to ensure that the encryption key was transmitted without error.</p> 
+     * <p>This functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerKeyMD5() const{ return m_sSECustomerKeyMD5; }
+    inline bool SSECustomerKeyMD5HasBeenSet() const { return m_sSECustomerKeyMD5HasBeenSet; }
+    inline void SetSSECustomerKeyMD5(const Aws::String& value) { m_sSECustomerKeyMD5HasBeenSet = true; m_sSECustomerKeyMD5 = value; }
+    inline void SetSSECustomerKeyMD5(Aws::String&& value) { m_sSECustomerKeyMD5HasBeenSet = true; m_sSECustomerKeyMD5 = std::move(value); }
+    inline void SetSSECustomerKeyMD5(const char* value) { m_sSECustomerKeyMD5HasBeenSet = true; m_sSECustomerKeyMD5.assign(value); }
+    inline CreateMultipartUploadRequest& WithSSECustomerKeyMD5(const Aws::String& value) { SetSSECustomerKeyMD5(value); return *this;}
+    inline CreateMultipartUploadRequest& WithSSECustomerKeyMD5(Aws::String&& value) { SetSSECustomerKeyMD5(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithSSECustomerKeyMD5(const char* value) { SetSSECustomerKeyMD5(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the KMS key ID (Key ID, Key ARN, or Key Alias) to use for object
+     * encryption. If the KMS key doesn't exist in the same account that's issuing the
+     * command, you must use the full Key ARN not the Key ID.</p> <p> <b>General
+     * purpose buckets</b> - If you specify <code>x-amz-server-side-encryption</code>
+     * with <code>aws:kms</code> or <code>aws:kms:dsse</code>, this header specifies
+     * the ID (Key ID, Key ARN, or Key Alias) of the KMS key to use. If you specify
+     * <code>x-amz-server-side-encryption:aws:kms</code> or
+     * <code>x-amz-server-side-encryption:aws:kms:dsse</code>, but do not provide
+     * <code>x-amz-server-side-encryption-aws-kms-key-id</code>, Amazon S3 uses the
+     * Amazon Web Services managed key (<code>aws/s3</code>) to protect the data.</p>
+     * <p> <b>Directory buckets</b> - If you specify
+     * <code>x-amz-server-side-encryption</code> with <code>aws:kms</code>, the <code>
+     * x-amz-server-side-encryption-aws-kms-key-id</code> header is implicitly assigned
+     * the ID of the KMS symmetric encryption customer managed key that's configured
+     * for your directory bucket's default encryption setting. If you want to specify
+     * the <code> x-amz-server-side-encryption-aws-kms-key-id</code> header explicitly,
+     * you can only specify it with the ID (Key ID or Key ARN) of the KMS customer
+     * managed key that's configured for your directory bucket's default encryption
+     * setting. Otherwise, you get an HTTP <code>400 Bad Request</code> error. Only use
+     * the key ID or key ARN. The key alias format of the KMS key isn't supported. Your
+     * SSE-KMS configuration can only support 1 <a
+     * href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk">customer
+     * managed key</a> per directory bucket for the lifetime of the bucket. The <a
+     * href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk">Amazon
+     * Web Services managed key</a> (<code>aws/s3</code>) isn't supported. </p>
+     */
+    inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
+    inline bool SSEKMSKeyIdHasBeenSet() const { return m_sSEKMSKeyIdHasBeenSet; }
+    inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId = value; }
+    inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId = std::move(value); }
+    inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId.assign(value); }
+    inline CreateMultipartUploadRequest& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
+    inline CreateMultipartUploadRequest& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the Amazon Web Services KMS Encryption Context to use for object
+     * encryption. The value of this header is a Base64-encoded string of a UTF-8
+     * encoded JSON, which contains the encryption context as key-value pairs.</p> <p>
+     * <b>Directory buckets</b> - You can optionally provide an explicit encryption
+     * context value. The value must match the default encryption context - the bucket
+     * Amazon Resource Name (ARN). An additional encryption context value is not
+     * supported. </p>
+     */
+    inline const Aws::String& GetSSEKMSEncryptionContext() const{ return m_sSEKMSEncryptionContext; }
+    inline bool SSEKMSEncryptionContextHasBeenSet() const { return m_sSEKMSEncryptionContextHasBeenSet; }
+    inline void SetSSEKMSEncryptionContext(const Aws::String& value) { m_sSEKMSEncryptionContextHasBeenSet = true; m_sSEKMSEncryptionContext = value; }
+    inline void SetSSEKMSEncryptionContext(Aws::String&& value) { m_sSEKMSEncryptionContextHasBeenSet = true; m_sSEKMSEncryptionContext = std::move(value); }
+    inline void SetSSEKMSEncryptionContext(const char* value) { m_sSEKMSEncryptionContextHasBeenSet = true; m_sSEKMSEncryptionContext.assign(value); }
+    inline CreateMultipartUploadRequest& WithSSEKMSEncryptionContext(const Aws::String& value) { SetSSEKMSEncryptionContext(value); return *this;}
+    inline CreateMultipartUploadRequest& WithSSEKMSEncryptionContext(Aws::String&& value) { SetSSEKMSEncryptionContext(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithSSEKMSEncryptionContext(const char* value) { SetSSEKMSEncryptionContext(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption
+     * with server-side encryption using Key Management Service (KMS) keys
+     * (SSE-KMS).</p> <p> <b>General purpose buckets</b> - Setting this header to
+     * <code>true</code> causes Amazon S3 to use an S3 Bucket Key for object encryption
+     * with SSE-KMS. Also, specifying this header with a PUT action doesn't affect
+     * bucket-level settings for S3 Bucket Key.</p> <p> <b>Directory buckets</b> - S3
+     * Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code>
+     * operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't
+     * supported, when you copy SSE-KMS encrypted objects from general purpose buckets
+     * to directory buckets, from directory buckets to general purpose buckets, or
+     * between directory buckets, through <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>,
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>,
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the
+     * Copy operation in Batch Operations</a>, or <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the
+     * import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy
+     * request is made for a KMS-encrypted object.</p>
+     */
+    inline bool GetBucketKeyEnabled() const{ return m_bucketKeyEnabled; }
+    inline bool BucketKeyEnabledHasBeenSet() const { return m_bucketKeyEnabledHasBeenSet; }
+    inline void SetBucketKeyEnabled(bool value) { m_bucketKeyEnabledHasBeenSet = true; m_bucketKeyEnabled = value; }
+    inline CreateMultipartUploadRequest& WithBucketKeyEnabled(bool value) { SetBucketKeyEnabled(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestPayer& GetRequestPayer() const{ return m_requestPayer; }
+    inline bool RequestPayerHasBeenSet() const { return m_requestPayerHasBeenSet; }
+    inline void SetRequestPayer(const RequestPayer& value) { m_requestPayerHasBeenSet = true; m_requestPayer = value; }
+    inline void SetRequestPayer(RequestPayer&& value) { m_requestPayerHasBeenSet = true; m_requestPayer = std::move(value); }
+    inline CreateMultipartUploadRequest& WithRequestPayer(const RequestPayer& value) { SetRequestPayer(value); return *this;}
+    inline CreateMultipartUploadRequest& WithRequestPayer(RequestPayer&& value) { SetRequestPayer(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The tag-set for the object. The tag-set must be encoded as URL Query
+     * parameters.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetTagging() const{ return m_tagging; }
+    inline bool TaggingHasBeenSet() const { return m_taggingHasBeenSet; }
+    inline void SetTagging(const Aws::String& value) { m_taggingHasBeenSet = true; m_tagging = value; }
+    inline void SetTagging(Aws::String&& value) { m_taggingHasBeenSet = true; m_tagging = std::move(value); }
+    inline void SetTagging(const char* value) { m_taggingHasBeenSet = true; m_tagging.assign(value); }
+    inline CreateMultipartUploadRequest& WithTagging(const Aws::String& value) { SetTagging(value); return *this;}
+    inline CreateMultipartUploadRequest& WithTagging(Aws::String&& value) { SetTagging(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithTagging(const char* value) { SetTagging(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the Object Lock mode that you want to apply to the uploaded
+     * object.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const ObjectLockMode& GetObjectLockMode() const{ return m_objectLockMode; }
+    inline bool ObjectLockModeHasBeenSet() const { return m_objectLockModeHasBeenSet; }
+    inline void SetObjectLockMode(const ObjectLockMode& value) { m_objectLockModeHasBeenSet = true; m_objectLockMode = value; }
+    inline void SetObjectLockMode(ObjectLockMode&& value) { m_objectLockModeHasBeenSet = true; m_objectLockMode = std::move(value); }
+    inline CreateMultipartUploadRequest& WithObjectLockMode(const ObjectLockMode& value) { SetObjectLockMode(value); return *this;}
+    inline CreateMultipartUploadRequest& WithObjectLockMode(ObjectLockMode&& value) { SetObjectLockMode(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the date and time when you want the Object Lock to expire.</p>
+     *  <p>This functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::Utils::DateTime& GetObjectLockRetainUntilDate() const{ return m_objectLockRetainUntilDate; }
+    inline bool ObjectLockRetainUntilDateHasBeenSet() const { return m_objectLockRetainUntilDateHasBeenSet; }
+    inline void SetObjectLockRetainUntilDate(const Aws::Utils::DateTime& value) { m_objectLockRetainUntilDateHasBeenSet = true; m_objectLockRetainUntilDate = value; }
+    inline void SetObjectLockRetainUntilDate(Aws::Utils::DateTime&& value) { m_objectLockRetainUntilDateHasBeenSet = true; m_objectLockRetainUntilDate = std::move(value); }
+    inline CreateMultipartUploadRequest& WithObjectLockRetainUntilDate(const Aws::Utils::DateTime& value) { SetObjectLockRetainUntilDate(value); return *this;}
+    inline CreateMultipartUploadRequest& WithObjectLockRetainUntilDate(Aws::Utils::DateTime&& value) { SetObjectLockRetainUntilDate(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies whether you want to apply a legal hold to the uploaded object.</p>
+     *  <p>This functionality is not supported for directory buckets.</p> 
+     */
+    inline const ObjectLockLegalHoldStatus& GetObjectLockLegalHoldStatus() const{ return m_objectLockLegalHoldStatus; }
+    inline bool ObjectLockLegalHoldStatusHasBeenSet() const { return m_objectLockLegalHoldStatusHasBeenSet; }
+    inline void SetObjectLockLegalHoldStatus(const ObjectLockLegalHoldStatus& value) { m_objectLockLegalHoldStatusHasBeenSet = true; m_objectLockLegalHoldStatus = value; }
+    inline void SetObjectLockLegalHoldStatus(ObjectLockLegalHoldStatus&& value) { m_objectLockLegalHoldStatusHasBeenSet = true; m_objectLockLegalHoldStatus = std::move(value); }
+    inline CreateMultipartUploadRequest& WithObjectLockLegalHoldStatus(const ObjectLockLegalHoldStatus& value) { SetObjectLockLegalHoldStatus(value); return *this;}
+    inline CreateMultipartUploadRequest& WithObjectLockLegalHoldStatus(ObjectLockLegalHoldStatus&& value) { SetObjectLockLegalHoldStatus(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline CreateMultipartUploadRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline CreateMultipartUploadRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates the algorithm that you want Amazon S3 to use to create the checksum
+     * for the object. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const ChecksumAlgorithm& GetChecksumAlgorithm() const{ return m_checksumAlgorithm; }
+    inline bool ChecksumAlgorithmHasBeenSet() const { return m_checksumAlgorithmHasBeenSet; }
+    inline void SetChecksumAlgorithm(const ChecksumAlgorithm& value) { m_checksumAlgorithmHasBeenSet = true; m_checksumAlgorithm = value; }
+    inline void SetChecksumAlgorithm(ChecksumAlgorithm&& value) { m_checksumAlgorithmHasBeenSet = true; m_checksumAlgorithm = std::move(value); }
+    inline CreateMultipartUploadRequest& WithChecksumAlgorithm(const ChecksumAlgorithm& value) { SetChecksumAlgorithm(value); return *this;}
+    inline CreateMultipartUploadRequest& WithChecksumAlgorithm(ChecksumAlgorithm&& value) { SetChecksumAlgorithm(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline CreateMultipartUploadRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline CreateMultipartUploadRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CreateMultipartUploadRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    ObjectCannedACL m_aCL;
+    bool m_aCLHasBeenSet = false;
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_cacheControl;
+    bool m_cacheControlHasBeenSet = false;
+
+    Aws::String m_contentDisposition;
+    bool m_contentDispositionHasBeenSet = false;
+
+    Aws::String m_contentEncoding;
+    bool m_contentEncodingHasBeenSet = false;
+
+    Aws::String m_contentLanguage;
+    bool m_contentLanguageHasBeenSet = false;
+
+    Aws::String m_contentType;
+    bool m_contentTypeHasBeenSet = false;
+
+    Aws::Utils::DateTime m_expires;
+    bool m_expiresHasBeenSet = false;
+
+    Aws::String m_grantFullControl;
+    bool m_grantFullControlHasBeenSet = false;
+
+    Aws::String m_grantRead;
+    bool m_grantReadHasBeenSet = false;
+
+    Aws::String m_grantReadACP;
+    bool m_grantReadACPHasBeenSet = false;
+
+    Aws::String m_grantWriteACP;
+    bool m_grantWriteACPHasBeenSet = false;
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_metadata;
+    bool m_metadataHasBeenSet = false;
+
+    ServerSideEncryption m_serverSideEncryption;
+    bool m_serverSideEncryptionHasBeenSet = false;
+
+    StorageClass m_storageClass;
+    bool m_storageClassHasBeenSet = false;
+
+    Aws::String m_websiteRedirectLocation;
+    bool m_websiteRedirectLocationHasBeenSet = false;
+
+    Aws::String m_sSECustomerAlgorithm;
+    bool m_sSECustomerAlgorithmHasBeenSet = false;
+
+    Aws::String m_sSECustomerKey;
+    bool m_sSECustomerKeyHasBeenSet = false;
+
+    Aws::String m_sSECustomerKeyMD5;
+    bool m_sSECustomerKeyMD5HasBeenSet = false;
+
+    Aws::String m_sSEKMSKeyId;
+    bool m_sSEKMSKeyIdHasBeenSet = false;
+
+    Aws::String m_sSEKMSEncryptionContext;
+    bool m_sSEKMSEncryptionContextHasBeenSet = false;
+
+    bool m_bucketKeyEnabled;
+    bool m_bucketKeyEnabledHasBeenSet = false;
+
+    RequestPayer m_requestPayer;
+    bool m_requestPayerHasBeenSet = false;
+
+    Aws::String m_tagging;
+    bool m_taggingHasBeenSet = false;
+
+    ObjectLockMode m_objectLockMode;
+    bool m_objectLockModeHasBeenSet = false;
+
+    Aws::Utils::DateTime m_objectLockRetainUntilDate;
+    bool m_objectLockRetainUntilDateHasBeenSet = false;
+
+    ObjectLockLegalHoldStatus m_objectLockLegalHoldStatus;
+    bool m_objectLockLegalHoldStatusHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    ChecksumAlgorithm m_checksumAlgorithm;
+    bool m_checksumAlgorithmHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateMultipartUploadResult.h

@@ -0,0 +1,264 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/DateTime.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/s3/model/RequestCharged.h>
+#include <aws/s3/model/ChecksumAlgorithm.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class CreateMultipartUploadResult
+  {
+  public:
+    AWS_S3_API CreateMultipartUploadResult();
+    AWS_S3_API CreateMultipartUploadResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API CreateMultipartUploadResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>If the bucket has a lifecycle rule configured with an action to abort
+     * incomplete multipart uploads and the prefix in the lifecycle rule matches the
+     * object name in the request, the response includes this header. The header
+     * indicates when the initiated multipart upload becomes eligible for an abort
+     * operation. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config">
+     * Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Configuration</a>
+     * in the <i>Amazon S3 User Guide</i>.</p> <p>The response also includes the
+     * <code>x-amz-abort-rule-id</code> header that provides the ID of the lifecycle
+     * configuration rule that defines the abort action.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::Utils::DateTime& GetAbortDate() const{ return m_abortDate; }
+    inline void SetAbortDate(const Aws::Utils::DateTime& value) { m_abortDate = value; }
+    inline void SetAbortDate(Aws::Utils::DateTime&& value) { m_abortDate = std::move(value); }
+    inline CreateMultipartUploadResult& WithAbortDate(const Aws::Utils::DateTime& value) { SetAbortDate(value); return *this;}
+    inline CreateMultipartUploadResult& WithAbortDate(Aws::Utils::DateTime&& value) { SetAbortDate(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>This header is returned along with the <code>x-amz-abort-date</code> header.
+     * It identifies the applicable lifecycle configuration rule that defines the
+     * action to abort incomplete multipart uploads.</p>  <p>This functionality
+     * is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetAbortRuleId() const{ return m_abortRuleId; }
+    inline void SetAbortRuleId(const Aws::String& value) { m_abortRuleId = value; }
+    inline void SetAbortRuleId(Aws::String&& value) { m_abortRuleId = std::move(value); }
+    inline void SetAbortRuleId(const char* value) { m_abortRuleId.assign(value); }
+    inline CreateMultipartUploadResult& WithAbortRuleId(const Aws::String& value) { SetAbortRuleId(value); return *this;}
+    inline CreateMultipartUploadResult& WithAbortRuleId(Aws::String&& value) { SetAbortRuleId(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithAbortRuleId(const char* value) { SetAbortRuleId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The name of the bucket to which the multipart upload was initiated. Does not
+     * return the access point ARN or access point alias if used.</p>  <p>Access
+     * points are not supported by directory buckets.</p> 
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline void SetBucket(const Aws::String& value) { m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucket.assign(value); }
+    inline CreateMultipartUploadResult& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline CreateMultipartUploadResult& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Object key for which the multipart upload was initiated.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline void SetKey(const Aws::String& value) { m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_key.assign(value); }
+    inline CreateMultipartUploadResult& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline CreateMultipartUploadResult& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>ID for the initiated multipart upload.</p>
+     */
+    inline const Aws::String& GetUploadId() const{ return m_uploadId; }
+    inline void SetUploadId(const Aws::String& value) { m_uploadId = value; }
+    inline void SetUploadId(Aws::String&& value) { m_uploadId = std::move(value); }
+    inline void SetUploadId(const char* value) { m_uploadId.assign(value); }
+    inline CreateMultipartUploadResult& WithUploadId(const Aws::String& value) { SetUploadId(value); return *this;}
+    inline CreateMultipartUploadResult& WithUploadId(Aws::String&& value) { SetUploadId(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithUploadId(const char* value) { SetUploadId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm used when you store this object in
+     * Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>).</p>
+     */
+    inline const ServerSideEncryption& GetServerSideEncryption() const{ return m_serverSideEncryption; }
+    inline void SetServerSideEncryption(const ServerSideEncryption& value) { m_serverSideEncryption = value; }
+    inline void SetServerSideEncryption(ServerSideEncryption&& value) { m_serverSideEncryption = std::move(value); }
+    inline CreateMultipartUploadResult& WithServerSideEncryption(const ServerSideEncryption& value) { SetServerSideEncryption(value); return *this;}
+    inline CreateMultipartUploadResult& WithServerSideEncryption(ServerSideEncryption&& value) { SetServerSideEncryption(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If server-side encryption with a customer-provided encryption key was
+     * requested, the response will include this header to confirm the encryption
+     * algorithm that's used.</p>  <p>This functionality is not supported for
+     * directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerAlgorithm() const{ return m_sSECustomerAlgorithm; }
+    inline void SetSSECustomerAlgorithm(const Aws::String& value) { m_sSECustomerAlgorithm = value; }
+    inline void SetSSECustomerAlgorithm(Aws::String&& value) { m_sSECustomerAlgorithm = std::move(value); }
+    inline void SetSSECustomerAlgorithm(const char* value) { m_sSECustomerAlgorithm.assign(value); }
+    inline CreateMultipartUploadResult& WithSSECustomerAlgorithm(const Aws::String& value) { SetSSECustomerAlgorithm(value); return *this;}
+    inline CreateMultipartUploadResult& WithSSECustomerAlgorithm(Aws::String&& value) { SetSSECustomerAlgorithm(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithSSECustomerAlgorithm(const char* value) { SetSSECustomerAlgorithm(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If server-side encryption with a customer-provided encryption key was
+     * requested, the response will include this header to provide the round-trip
+     * message integrity verification of the customer-provided encryption key.</p>
+     *  <p>This functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetSSECustomerKeyMD5() const{ return m_sSECustomerKeyMD5; }
+    inline void SetSSECustomerKeyMD5(const Aws::String& value) { m_sSECustomerKeyMD5 = value; }
+    inline void SetSSECustomerKeyMD5(Aws::String&& value) { m_sSECustomerKeyMD5 = std::move(value); }
+    inline void SetSSECustomerKeyMD5(const char* value) { m_sSECustomerKeyMD5.assign(value); }
+    inline CreateMultipartUploadResult& WithSSECustomerKeyMD5(const Aws::String& value) { SetSSECustomerKeyMD5(value); return *this;}
+    inline CreateMultipartUploadResult& WithSSECustomerKeyMD5(Aws::String&& value) { SetSSECustomerKeyMD5(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithSSECustomerKeyMD5(const char* value) { SetSSECustomerKeyMD5(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If present, indicates the ID of the KMS key that was used for object
+     * encryption.</p>
+     */
+    inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
+    inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyId = value; }
+    inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyId = std::move(value); }
+    inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyId.assign(value); }
+    inline CreateMultipartUploadResult& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
+    inline CreateMultipartUploadResult& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If present, indicates the Amazon Web Services KMS Encryption Context to use
+     * for object encryption. The value of this header is a Base64-encoded string of a
+     * UTF-8 encoded JSON, which contains the encryption context as key-value
+     * pairs.</p>
+     */
+    inline const Aws::String& GetSSEKMSEncryptionContext() const{ return m_sSEKMSEncryptionContext; }
+    inline void SetSSEKMSEncryptionContext(const Aws::String& value) { m_sSEKMSEncryptionContext = value; }
+    inline void SetSSEKMSEncryptionContext(Aws::String&& value) { m_sSEKMSEncryptionContext = std::move(value); }
+    inline void SetSSEKMSEncryptionContext(const char* value) { m_sSEKMSEncryptionContext.assign(value); }
+    inline CreateMultipartUploadResult& WithSSEKMSEncryptionContext(const Aws::String& value) { SetSSEKMSEncryptionContext(value); return *this;}
+    inline CreateMultipartUploadResult& WithSSEKMSEncryptionContext(Aws::String&& value) { SetSSEKMSEncryptionContext(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithSSEKMSEncryptionContext(const char* value) { SetSSEKMSEncryptionContext(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates whether the multipart upload uses an S3 Bucket Key for server-side
+     * encryption with Key Management Service (KMS) keys (SSE-KMS).</p>
+     */
+    inline bool GetBucketKeyEnabled() const{ return m_bucketKeyEnabled; }
+    inline void SetBucketKeyEnabled(bool value) { m_bucketKeyEnabled = value; }
+    inline CreateMultipartUploadResult& WithBucketKeyEnabled(bool value) { SetBucketKeyEnabled(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestCharged& GetRequestCharged() const{ return m_requestCharged; }
+    inline void SetRequestCharged(const RequestCharged& value) { m_requestCharged = value; }
+    inline void SetRequestCharged(RequestCharged&& value) { m_requestCharged = std::move(value); }
+    inline CreateMultipartUploadResult& WithRequestCharged(const RequestCharged& value) { SetRequestCharged(value); return *this;}
+    inline CreateMultipartUploadResult& WithRequestCharged(RequestCharged&& value) { SetRequestCharged(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The algorithm that was used to create a checksum of the object.</p>
+     */
+    inline const ChecksumAlgorithm& GetChecksumAlgorithm() const{ return m_checksumAlgorithm; }
+    inline void SetChecksumAlgorithm(const ChecksumAlgorithm& value) { m_checksumAlgorithm = value; }
+    inline void SetChecksumAlgorithm(ChecksumAlgorithm&& value) { m_checksumAlgorithm = std::move(value); }
+    inline CreateMultipartUploadResult& WithChecksumAlgorithm(const ChecksumAlgorithm& value) { SetChecksumAlgorithm(value); return *this;}
+    inline CreateMultipartUploadResult& WithChecksumAlgorithm(ChecksumAlgorithm&& value) { SetChecksumAlgorithm(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline CreateMultipartUploadResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline CreateMultipartUploadResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline CreateMultipartUploadResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::Utils::DateTime m_abortDate;
+
+    Aws::String m_abortRuleId;
+
+    Aws::String m_bucket;
+
+    Aws::String m_key;
+
+    Aws::String m_uploadId;
+
+    ServerSideEncryption m_serverSideEncryption;
+
+    Aws::String m_sSECustomerAlgorithm;
+
+    Aws::String m_sSECustomerKeyMD5;
+
+    Aws::String m_sSEKMSKeyId;
+
+    Aws::String m_sSEKMSEncryptionContext;
+
+    bool m_bucketKeyEnabled;
+
+    RequestCharged m_requestCharged;
+
+    ChecksumAlgorithm m_checksumAlgorithm;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateSessionRequest.h

@@ -0,0 +1,223 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/s3/model/SessionMode.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class CreateSessionRequest : public S3Request
+  {
+  public:
+    AWS_S3_API CreateSessionRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "CreateSession"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>Specifies the mode of the session that will be created, either
+     * <code>ReadWrite</code> or <code>ReadOnly</code>. By default, a
+     * <code>ReadWrite</code> session is created. A <code>ReadWrite</code> session is
+     * capable of executing all the Zonal endpoint API operations on a directory
+     * bucket. A <code>ReadOnly</code> session is constrained to execute the following
+     * Zonal endpoint API operations: <code>GetObject</code>, <code>HeadObject</code>,
+     * <code>ListObjectsV2</code>, <code>GetObjectAttributes</code>,
+     * <code>ListParts</code>, and <code>ListMultipartUploads</code>.</p>
+     */
+    inline const SessionMode& GetSessionMode() const{ return m_sessionMode; }
+    inline bool SessionModeHasBeenSet() const { return m_sessionModeHasBeenSet; }
+    inline void SetSessionMode(const SessionMode& value) { m_sessionModeHasBeenSet = true; m_sessionMode = value; }
+    inline void SetSessionMode(SessionMode&& value) { m_sessionModeHasBeenSet = true; m_sessionMode = std::move(value); }
+    inline CreateSessionRequest& WithSessionMode(const SessionMode& value) { SetSessionMode(value); return *this;}
+    inline CreateSessionRequest& WithSessionMode(SessionMode&& value) { SetSessionMode(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The name of the bucket that you create a session for.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline CreateSessionRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline CreateSessionRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline CreateSessionRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm to use when you store objects in the
+     * directory bucket.</p> <p>For directory buckets, there are only two supported
+     * options for server-side encryption: server-side encryption with Amazon S3
+     * managed keys (SSE-S3) (<code>AES256</code>) and server-side encryption with KMS
+     * keys (SSE-KMS) (<code>aws:kms</code>). By default, Amazon S3 encrypts data with
+     * SSE-S3. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-serv-side-encryption.html">Protecting
+     * data with server-side encryption</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const ServerSideEncryption& GetServerSideEncryption() const{ return m_serverSideEncryption; }
+    inline bool ServerSideEncryptionHasBeenSet() const { return m_serverSideEncryptionHasBeenSet; }
+    inline void SetServerSideEncryption(const ServerSideEncryption& value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption = value; }
+    inline void SetServerSideEncryption(ServerSideEncryption&& value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption = std::move(value); }
+    inline CreateSessionRequest& WithServerSideEncryption(const ServerSideEncryption& value) { SetServerSideEncryption(value); return *this;}
+    inline CreateSessionRequest& WithServerSideEncryption(ServerSideEncryption&& value) { SetServerSideEncryption(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If you specify <code>x-amz-server-side-encryption</code> with
+     * <code>aws:kms</code>, you must specify the <code>
+     * x-amz-server-side-encryption-aws-kms-key-id</code> header with the ID (Key ID or
+     * Key ARN) of the KMS symmetric encryption customer managed key to use. Otherwise,
+     * you get an HTTP <code>400 Bad Request</code> error. Only use the key ID or key
+     * ARN. The key alias format of the KMS key isn't supported. Also, if the KMS key
+     * doesn't exist in the same account that't issuing the command, you must use the
+     * full Key ARN not the Key ID. </p> <p>Your SSE-KMS configuration can only support
+     * 1 <a
+     * href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk">customer
+     * managed key</a> per directory bucket for the lifetime of the bucket. The <a
+     * href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk">Amazon
+     * Web Services managed key</a> (<code>aws/s3</code>) isn't supported. </p>
+     */
+    inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
+    inline bool SSEKMSKeyIdHasBeenSet() const { return m_sSEKMSKeyIdHasBeenSet; }
+    inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId = value; }
+    inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId = std::move(value); }
+    inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId.assign(value); }
+    inline CreateSessionRequest& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
+    inline CreateSessionRequest& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
+    inline CreateSessionRequest& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies the Amazon Web Services KMS Encryption Context as an additional
+     * encryption context to use for object encryption. The value of this header is a
+     * Base64-encoded string of a UTF-8 encoded JSON, which contains the encryption
+     * context as key-value pairs. This value is stored as object metadata and
+     * automatically gets passed on to Amazon Web Services KMS for future
+     * <code>GetObject</code> operations on this object.</p> <p> <b>General purpose
+     * buckets</b> - This value must be explicitly added during <code>CopyObject</code>
+     * operations if you want an additional encryption context for your object. For
+     * more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html#encryption-context">Encryption
+     * context</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Directory buckets</b>
+     * - You can optionally provide an explicit encryption context value. The value
+     * must match the default encryption context - the bucket Amazon Resource Name
+     * (ARN). An additional encryption context value is not supported. </p>
+     */
+    inline const Aws::String& GetSSEKMSEncryptionContext() const{ return m_sSEKMSEncryptionContext; }
+    inline bool SSEKMSEncryptionContextHasBeenSet() const { return m_sSEKMSEncryptionContextHasBeenSet; }
+    inline void SetSSEKMSEncryptionContext(const Aws::String& value) { m_sSEKMSEncryptionContextHasBeenSet = true; m_sSEKMSEncryptionContext = value; }
+    inline void SetSSEKMSEncryptionContext(Aws::String&& value) { m_sSEKMSEncryptionContextHasBeenSet = true; m_sSEKMSEncryptionContext = std::move(value); }
+    inline void SetSSEKMSEncryptionContext(const char* value) { m_sSEKMSEncryptionContextHasBeenSet = true; m_sSEKMSEncryptionContext.assign(value); }
+    inline CreateSessionRequest& WithSSEKMSEncryptionContext(const Aws::String& value) { SetSSEKMSEncryptionContext(value); return *this;}
+    inline CreateSessionRequest& WithSSEKMSEncryptionContext(Aws::String&& value) { SetSSEKMSEncryptionContext(std::move(value)); return *this;}
+    inline CreateSessionRequest& WithSSEKMSEncryptionContext(const char* value) { SetSSEKMSEncryptionContext(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies whether Amazon S3 should use an S3 Bucket Key for object encryption
+     * with server-side encryption using KMS keys (SSE-KMS).</p> <p>S3 Bucket Keys are
+     * always enabled for <code>GET</code> and <code>PUT</code> operations in a
+     * directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when
+     * you copy SSE-KMS encrypted objects from general purpose buckets to directory
+     * buckets, from directory buckets to general purpose buckets, or between directory
+     * buckets, through <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>,
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>,
+     * <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the
+     * Copy operation in Batch Operations</a>, or <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the
+     * import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy
+     * request is made for a KMS-encrypted object.</p>
+     */
+    inline bool GetBucketKeyEnabled() const{ return m_bucketKeyEnabled; }
+    inline bool BucketKeyEnabledHasBeenSet() const { return m_bucketKeyEnabledHasBeenSet; }
+    inline void SetBucketKeyEnabled(bool value) { m_bucketKeyEnabledHasBeenSet = true; m_bucketKeyEnabled = value; }
+    inline CreateSessionRequest& WithBucketKeyEnabled(bool value) { SetBucketKeyEnabled(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline CreateSessionRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline CreateSessionRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline CreateSessionRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    SessionMode m_sessionMode;
+    bool m_sessionModeHasBeenSet = false;
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    ServerSideEncryption m_serverSideEncryption;
+    bool m_serverSideEncryptionHasBeenSet = false;
+
+    Aws::String m_sSEKMSKeyId;
+    bool m_sSEKMSKeyIdHasBeenSet = false;
+
+    Aws::String m_sSEKMSEncryptionContext;
+    bool m_sSEKMSEncryptionContextHasBeenSet = false;
+
+    bool m_bucketKeyEnabled;
+    bool m_bucketKeyEnabledHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/CreateSessionResult.h

@@ -0,0 +1,130 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/SessionCredentials.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class CreateSessionResult
+  {
+  public:
+    AWS_S3_API CreateSessionResult();
+    AWS_S3_API CreateSessionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API CreateSessionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm used when you store objects in the
+     * directory bucket.</p>
+     */
+    inline const ServerSideEncryption& GetServerSideEncryption() const{ return m_serverSideEncryption; }
+    inline void SetServerSideEncryption(const ServerSideEncryption& value) { m_serverSideEncryption = value; }
+    inline void SetServerSideEncryption(ServerSideEncryption&& value) { m_serverSideEncryption = std::move(value); }
+    inline CreateSessionResult& WithServerSideEncryption(const ServerSideEncryption& value) { SetServerSideEncryption(value); return *this;}
+    inline CreateSessionResult& WithServerSideEncryption(ServerSideEncryption&& value) { SetServerSideEncryption(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If you specify <code>x-amz-server-side-encryption</code> with
+     * <code>aws:kms</code>, this header indicates the ID of the KMS symmetric
+     * encryption customer managed key that was used for object encryption.</p>
+     */
+    inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
+    inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyId = value; }
+    inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyId = std::move(value); }
+    inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyId.assign(value); }
+    inline CreateSessionResult& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
+    inline CreateSessionResult& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
+    inline CreateSessionResult& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If present, indicates the Amazon Web Services KMS Encryption Context to use
+     * for object encryption. The value of this header is a Base64-encoded string of a
+     * UTF-8 encoded JSON, which contains the encryption context as key-value pairs.
+     * This value is stored as object metadata and automatically gets passed on to
+     * Amazon Web Services KMS for future <code>GetObject</code> operations on this
+     * object.</p>
+     */
+    inline const Aws::String& GetSSEKMSEncryptionContext() const{ return m_sSEKMSEncryptionContext; }
+    inline void SetSSEKMSEncryptionContext(const Aws::String& value) { m_sSEKMSEncryptionContext = value; }
+    inline void SetSSEKMSEncryptionContext(Aws::String&& value) { m_sSEKMSEncryptionContext = std::move(value); }
+    inline void SetSSEKMSEncryptionContext(const char* value) { m_sSEKMSEncryptionContext.assign(value); }
+    inline CreateSessionResult& WithSSEKMSEncryptionContext(const Aws::String& value) { SetSSEKMSEncryptionContext(value); return *this;}
+    inline CreateSessionResult& WithSSEKMSEncryptionContext(Aws::String&& value) { SetSSEKMSEncryptionContext(std::move(value)); return *this;}
+    inline CreateSessionResult& WithSSEKMSEncryptionContext(const char* value) { SetSSEKMSEncryptionContext(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates whether to use an S3 Bucket Key for server-side encryption with KMS
+     * keys (SSE-KMS).</p>
+     */
+    inline bool GetBucketKeyEnabled() const{ return m_bucketKeyEnabled; }
+    inline void SetBucketKeyEnabled(bool value) { m_bucketKeyEnabled = value; }
+    inline CreateSessionResult& WithBucketKeyEnabled(bool value) { SetBucketKeyEnabled(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The established temporary security credentials for the created session.</p>
+     */
+    inline const SessionCredentials& GetCredentials() const{ return m_credentials; }
+    inline void SetCredentials(const SessionCredentials& value) { m_credentials = value; }
+    inline void SetCredentials(SessionCredentials&& value) { m_credentials = std::move(value); }
+    inline CreateSessionResult& WithCredentials(const SessionCredentials& value) { SetCredentials(value); return *this;}
+    inline CreateSessionResult& WithCredentials(SessionCredentials&& value) { SetCredentials(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline CreateSessionResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline CreateSessionResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline CreateSessionResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    ServerSideEncryption m_serverSideEncryption;
+
+    Aws::String m_sSEKMSKeyId;
+
+    Aws::String m_sSEKMSEncryptionContext;
+
+    bool m_bucketKeyEnabled;
+
+    SessionCredentials m_credentials;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DataRedundancy.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class DataRedundancy
+  {
+    NOT_SET,
+    SingleAvailabilityZone
+  };
+
+namespace DataRedundancyMapper
+{
+AWS_S3_API DataRedundancy GetDataRedundancyForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForDataRedundancy(DataRedundancy value);
+} // namespace DataRedundancyMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DefaultRetention.h

@@ -0,0 +1,95 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/ObjectLockRetentionMode.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>The container element for optionally specifying the default Object Lock
+   * retention settings for new objects placed in the specified bucket.</p> 
+   * <ul> <li> <p>The <code>DefaultRetention</code> settings require both a mode and
+   * a period.</p> </li> <li> <p>The <code>DefaultRetention</code> period can be
+   * either <code>Days</code> or <code>Years</code> but you must select one. You
+   * cannot specify <code>Days</code> and <code>Years</code> at the same time.</p>
+   * </li> </ul> <p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DefaultRetention">AWS
+   * API Reference</a></p>
+   */
+  class DefaultRetention
+  {
+  public:
+    AWS_S3_API DefaultRetention();
+    AWS_S3_API DefaultRetention(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API DefaultRetention& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The default Object Lock retention mode you want to apply to new objects
+     * placed in the specified bucket. Must be used with either <code>Days</code> or
+     * <code>Years</code>.</p>
+     */
+    inline const ObjectLockRetentionMode& GetMode() const{ return m_mode; }
+    inline bool ModeHasBeenSet() const { return m_modeHasBeenSet; }
+    inline void SetMode(const ObjectLockRetentionMode& value) { m_modeHasBeenSet = true; m_mode = value; }
+    inline void SetMode(ObjectLockRetentionMode&& value) { m_modeHasBeenSet = true; m_mode = std::move(value); }
+    inline DefaultRetention& WithMode(const ObjectLockRetentionMode& value) { SetMode(value); return *this;}
+    inline DefaultRetention& WithMode(ObjectLockRetentionMode&& value) { SetMode(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The number of days that you want to specify for the default retention period.
+     * Must be used with <code>Mode</code>.</p>
+     */
+    inline int GetDays() const{ return m_days; }
+    inline bool DaysHasBeenSet() const { return m_daysHasBeenSet; }
+    inline void SetDays(int value) { m_daysHasBeenSet = true; m_days = value; }
+    inline DefaultRetention& WithDays(int value) { SetDays(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The number of years that you want to specify for the default retention
+     * period. Must be used with <code>Mode</code>.</p>
+     */
+    inline int GetYears() const{ return m_years; }
+    inline bool YearsHasBeenSet() const { return m_yearsHasBeenSet; }
+    inline void SetYears(int value) { m_yearsHasBeenSet = true; m_years = value; }
+    inline DefaultRetention& WithYears(int value) { SetYears(value); return *this;}
+    ///@}
+  private:
+
+    ObjectLockRetentionMode m_mode;
+    bool m_modeHasBeenSet = false;
+
+    int m_days;
+    bool m_daysHasBeenSet = false;
+
+    int m_years;
+    bool m_yearsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Delete.h

@@ -0,0 +1,80 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/ObjectIdentifier.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for the objects to delete.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Delete">AWS API
+   * Reference</a></p>
+   */
+  class Delete
+  {
+  public:
+    AWS_S3_API Delete();
+    AWS_S3_API Delete(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Delete& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The object to delete.</p>  <p> <b>Directory buckets</b> - For directory
+     * buckets, an object that's composed entirely of whitespace characters is not
+     * supported by the <code>DeleteObjects</code> API operation. The request will
+     * receive a <code>400 Bad Request</code> error and none of the objects in the
+     * request will be deleted.</p> 
+     */
+    inline const Aws::Vector<ObjectIdentifier>& GetObjects() const{ return m_objects; }
+    inline bool ObjectsHasBeenSet() const { return m_objectsHasBeenSet; }
+    inline void SetObjects(const Aws::Vector<ObjectIdentifier>& value) { m_objectsHasBeenSet = true; m_objects = value; }
+    inline void SetObjects(Aws::Vector<ObjectIdentifier>&& value) { m_objectsHasBeenSet = true; m_objects = std::move(value); }
+    inline Delete& WithObjects(const Aws::Vector<ObjectIdentifier>& value) { SetObjects(value); return *this;}
+    inline Delete& WithObjects(Aws::Vector<ObjectIdentifier>&& value) { SetObjects(std::move(value)); return *this;}
+    inline Delete& AddObjects(const ObjectIdentifier& value) { m_objectsHasBeenSet = true; m_objects.push_back(value); return *this; }
+    inline Delete& AddObjects(ObjectIdentifier&& value) { m_objectsHasBeenSet = true; m_objects.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>Element to enable quiet mode for the request. When you add this element, you
+     * must set its value to <code>true</code>.</p>
+     */
+    inline bool GetQuiet() const{ return m_quiet; }
+    inline bool QuietHasBeenSet() const { return m_quietHasBeenSet; }
+    inline void SetQuiet(bool value) { m_quietHasBeenSet = true; m_quiet = value; }
+    inline Delete& WithQuiet(bool value) { SetQuiet(value); return *this;}
+    ///@}
+  private:
+
+    Aws::Vector<ObjectIdentifier> m_objects;
+    bool m_objectsHasBeenSet = false;
+
+    bool m_quiet;
+    bool m_quietHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketAnalyticsConfigurationRequest.h

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketAnalyticsConfigurationRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketAnalyticsConfigurationRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketAnalyticsConfiguration"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The name of the bucket from which an analytics configuration is deleted.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketAnalyticsConfigurationRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The ID that identifies the analytics configuration.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+    inline DeleteBucketAnalyticsConfigurationRequest& WithId(const Aws::String& value) { SetId(value); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithId(const char* value) { SetId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketAnalyticsConfigurationRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketAnalyticsConfigurationRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketAnalyticsConfigurationRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_id;
+    bool m_idHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketCorsRequest.h

@@ -0,0 +1,110 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketCorsRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketCorsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketCors"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>Specifies the bucket whose <code>cors</code> configuration is being
+     * deleted.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketCorsRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketCorsRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketCorsRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketCorsRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketCorsRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketCorsRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketCorsRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketCorsRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketCorsRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketEncryptionRequest.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketEncryptionRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketEncryptionRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketEncryption"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The name of the bucket containing the server-side encryption configuration to
+     * delete.</p> <p> <b>Directory buckets </b> - When you use this operation with a
+     * directory bucket, you must use path-style requests in the format
+     * <code>https://s3express-control.<i>region_code</i>.amazonaws.com/<i>bucket-name</i>
+     * </code>. Virtual-hosted-style requests aren't supported. Directory bucket names
+     * must be unique in the chosen Availability Zone. Bucket names must also follow
+     * the format <code> <i>bucket_base_name</i>--<i>az_id</i>--x-s3</code> (for
+     * example, <code> <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For
+     * information about bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i> </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketEncryptionRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketEncryptionRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketEncryptionRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p> 
+     * <p>For directory buckets, this header is not supported in this API operation. If
+     * you specify this header, the request fails with the HTTP status code <code>501
+     * Not Implemented</code>.</p> 
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketEncryptionRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketEncryptionRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketEncryptionRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketEncryptionRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketEncryptionRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketEncryptionRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketIntelligentTieringConfigurationRequest.h

@@ -0,0 +1,106 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketIntelligentTieringConfigurationRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketIntelligentTieringConfigurationRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketIntelligentTieringConfiguration"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The name of the Amazon S3 bucket whose configuration you want to modify or
+     * retrieve.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithId(const Aws::String& value) { SetId(value); return *this;}
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithId(const char* value) { SetId(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketIntelligentTieringConfigurationRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketIntelligentTieringConfigurationRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_id;
+    bool m_idHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketInventoryConfigurationRequest.h

@@ -0,0 +1,126 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketInventoryConfigurationRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketInventoryConfigurationRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketInventoryConfiguration"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The name of the bucket containing the inventory configuration to delete.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketInventoryConfigurationRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The ID used to identify the inventory configuration.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+    inline DeleteBucketInventoryConfigurationRequest& WithId(const Aws::String& value) { SetId(value); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithId(const char* value) { SetId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketInventoryConfigurationRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketInventoryConfigurationRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketInventoryConfigurationRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_id;
+    bool m_idHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketLifecycleRequest.h

@@ -0,0 +1,109 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketLifecycleRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketLifecycleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketLifecycle"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name of the lifecycle to delete.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketLifecycleRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketLifecycleRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketLifecycleRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketLifecycleRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketLifecycleRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketLifecycleRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketLifecycleRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketLifecycleRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketLifecycleRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketMetricsConfigurationRequest.h

@@ -0,0 +1,128 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketMetricsConfigurationRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketMetricsConfigurationRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketMetricsConfiguration"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The name of the bucket containing the metrics configuration to delete.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketMetricsConfigurationRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The ID used to identify the metrics configuration. The ID has a 64 character
+     * limit and can only contain letters, numbers, periods, dashes, and
+     * underscores.</p>
+     */
+    inline const Aws::String& GetId() const{ return m_id; }
+    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
+    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
+    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
+    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
+    inline DeleteBucketMetricsConfigurationRequest& WithId(const Aws::String& value) { SetId(value); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithId(const char* value) { SetId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketMetricsConfigurationRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketMetricsConfigurationRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketMetricsConfigurationRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_id;
+    bool m_idHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketOwnershipControlsRequest.h

@@ -0,0 +1,110 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketOwnershipControlsRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketOwnershipControlsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketOwnershipControls"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The Amazon S3 bucket whose <code>OwnershipControls</code> you want to delete.
+     * </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketOwnershipControlsRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketOwnershipControlsRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketOwnershipControlsRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketOwnershipControlsRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketOwnershipControlsRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketOwnershipControlsRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketOwnershipControlsRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketOwnershipControlsRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketOwnershipControlsRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketPolicyRequest.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketPolicyRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketPolicyRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketPolicy"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name.</p> <p> <b>Directory buckets </b> - When you use this
+     * operation with a directory bucket, you must use path-style requests in the
+     * format
+     * <code>https://s3express-control.<i>region_code</i>.amazonaws.com/<i>bucket-name</i>
+     * </code>. Virtual-hosted-style requests aren't supported. Directory bucket names
+     * must be unique in the chosen Availability Zone. Bucket names must also follow
+     * the format <code> <i>bucket_base_name</i>--<i>az_id</i>--x-s3</code> (for
+     * example, <code> <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For
+     * information about bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i> </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketPolicyRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketPolicyRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketPolicyRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p> 
+     * <p>For directory buckets, this header is not supported in this API operation. If
+     * you specify this header, the request fails with the HTTP status code <code>501
+     * Not Implemented</code>.</p> 
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketPolicyRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketPolicyRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketPolicyRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketPolicyRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketPolicyRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketPolicyRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketReplicationRequest.h

@@ -0,0 +1,109 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketReplicationRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketReplicationRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketReplication"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p> The bucket name. </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketReplicationRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketReplicationRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketReplicationRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketReplicationRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketReplicationRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketReplicationRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketReplicationRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketReplicationRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketReplicationRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketRequest.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucket"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>Specifies the bucket being deleted.</p> <p> <b>Directory buckets </b> - When
+     * you use this operation with a directory bucket, you must use path-style requests
+     * in the format
+     * <code>https://s3express-control.<i>region_code</i>.amazonaws.com/<i>bucket-name</i>
+     * </code>. Virtual-hosted-style requests aren't supported. Directory bucket names
+     * must be unique in the chosen Availability Zone. Bucket names must also follow
+     * the format <code> <i>bucket_base_name</i>--<i>az_id</i>--x-s3</code> (for
+     * example, <code> <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For
+     * information about bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i> </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p> 
+     * <p>For directory buckets, this header is not supported in this API operation. If
+     * you specify this header, the request fails with the HTTP status code <code>501
+     * Not Implemented</code>.</p> 
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketTaggingRequest.h

@@ -0,0 +1,109 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketTaggingRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketTaggingRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketTagging"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket that has the tag set to be removed.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketTaggingRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketTaggingRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketTaggingRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketTaggingRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketTaggingRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketTaggingRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketTaggingRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketTaggingRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketTaggingRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteBucketWebsiteRequest.h

@@ -0,0 +1,109 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteBucketWebsiteRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteBucketWebsiteRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteBucketWebsite"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name for which you want to remove the website configuration. </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteBucketWebsiteRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteBucketWebsiteRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteBucketWebsiteRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteBucketWebsiteRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteBucketWebsiteRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteBucketWebsiteRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteBucketWebsiteRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteBucketWebsiteRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteBucketWebsiteRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteMarkerEntry.h

@@ -0,0 +1,124 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/Owner.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about the delete marker.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteMarkerEntry">AWS
+   * API Reference</a></p>
+   */
+  class DeleteMarkerEntry
+  {
+  public:
+    AWS_S3_API DeleteMarkerEntry();
+    AWS_S3_API DeleteMarkerEntry(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API DeleteMarkerEntry& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The account that created the delete marker.&gt;</p>
+     */
+    inline const Owner& GetOwner() const{ return m_owner; }
+    inline bool OwnerHasBeenSet() const { return m_ownerHasBeenSet; }
+    inline void SetOwner(const Owner& value) { m_ownerHasBeenSet = true; m_owner = value; }
+    inline void SetOwner(Owner&& value) { m_ownerHasBeenSet = true; m_owner = std::move(value); }
+    inline DeleteMarkerEntry& WithOwner(const Owner& value) { SetOwner(value); return *this;}
+    inline DeleteMarkerEntry& WithOwner(Owner&& value) { SetOwner(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The object key.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline DeleteMarkerEntry& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline DeleteMarkerEntry& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline DeleteMarkerEntry& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Version ID of an object.</p>
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
+    inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
+    inline DeleteMarkerEntry& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline DeleteMarkerEntry& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline DeleteMarkerEntry& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies whether the object is (true) or is not (false) the latest version
+     * of an object.</p>
+     */
+    inline bool GetIsLatest() const{ return m_isLatest; }
+    inline bool IsLatestHasBeenSet() const { return m_isLatestHasBeenSet; }
+    inline void SetIsLatest(bool value) { m_isLatestHasBeenSet = true; m_isLatest = value; }
+    inline DeleteMarkerEntry& WithIsLatest(bool value) { SetIsLatest(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Date and time when the object was last modified.</p>
+     */
+    inline const Aws::Utils::DateTime& GetLastModified() const{ return m_lastModified; }
+    inline bool LastModifiedHasBeenSet() const { return m_lastModifiedHasBeenSet; }
+    inline void SetLastModified(const Aws::Utils::DateTime& value) { m_lastModifiedHasBeenSet = true; m_lastModified = value; }
+    inline void SetLastModified(Aws::Utils::DateTime&& value) { m_lastModifiedHasBeenSet = true; m_lastModified = std::move(value); }
+    inline DeleteMarkerEntry& WithLastModified(const Aws::Utils::DateTime& value) { SetLastModified(value); return *this;}
+    inline DeleteMarkerEntry& WithLastModified(Aws::Utils::DateTime&& value) { SetLastModified(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Owner m_owner;
+    bool m_ownerHasBeenSet = false;
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_versionId;
+    bool m_versionIdHasBeenSet = false;
+
+    bool m_isLatest;
+    bool m_isLatestHasBeenSet = false;
+
+    Aws::Utils::DateTime m_lastModified;
+    bool m_lastModifiedHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteMarkerReplication.h

@@ -0,0 +1,75 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/DeleteMarkerReplicationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies whether Amazon S3 replicates delete markers. If you specify a
+   * <code>Filter</code> in your replication configuration, you must also include a
+   * <code>DeleteMarkerReplication</code> element. If your <code>Filter</code>
+   * includes a <code>Tag</code> element, the <code>DeleteMarkerReplication</code>
+   * <code>Status</code> must be set to Disabled, because Amazon S3 does not support
+   * replicating delete markers for tag-based rules. For an example configuration,
+   * see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-config-min-rule-config">Basic
+   * Rule Configuration</a>. </p> <p>For more information about delete marker
+   * replication, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/delete-marker-replication.html">Basic
+   * Rule Configuration</a>. </p>  <p>If you are using an earlier version of
+   * the replication configuration, Amazon S3 handles replication of delete markers
+   * differently. For more information, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html#replication-backward-compat-considerations">Backward
+   * Compatibility</a>.</p> <p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeleteMarkerReplication">AWS
+   * API Reference</a></p>
+   */
+  class DeleteMarkerReplication
+  {
+  public:
+    AWS_S3_API DeleteMarkerReplication();
+    AWS_S3_API DeleteMarkerReplication(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API DeleteMarkerReplication& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Indicates whether to replicate delete markers.</p>  <p>Indicates
+     * whether to replicate delete markers.</p> 
+     */
+    inline const DeleteMarkerReplicationStatus& GetStatus() const{ return m_status; }
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+    inline void SetStatus(const DeleteMarkerReplicationStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+    inline void SetStatus(DeleteMarkerReplicationStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+    inline DeleteMarkerReplication& WithStatus(const DeleteMarkerReplicationStatus& value) { SetStatus(value); return *this;}
+    inline DeleteMarkerReplication& WithStatus(DeleteMarkerReplicationStatus&& value) { SetStatus(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    DeleteMarkerReplicationStatus m_status;
+    bool m_statusHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteMarkerReplicationStatus.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class DeleteMarkerReplicationStatus
+  {
+    NOT_SET,
+    Enabled,
+    Disabled
+  };
+
+namespace DeleteMarkerReplicationStatusMapper
+{
+AWS_S3_API DeleteMarkerReplicationStatus GetDeleteMarkerReplicationStatusForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForDeleteMarkerReplicationStatus(DeleteMarkerReplicationStatus value);
+} // namespace DeleteMarkerReplicationStatusMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteObjectRequest.h

@@ -0,0 +1,226 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/RequestPayer.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteObjectRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteObjectRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteObject"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name of the bucket containing the object. </p> <p> <b>Directory
+     * buckets</b> - When you use this operation with a directory bucket, you must use
+     * virtual-hosted-style requests in the format <code>
+     * <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>.
+     * Path-style requests are not supported. Directory bucket names must be unique in
+     * the chosen Availability Zone. Bucket names must follow the format <code>
+     * <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>
+     * <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about
+     * bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Access
+     * points</b> - When you use this action with an access point, you must provide the
+     * alias of the access point in place of the bucket name or specify the access
+     * point ARN. When using the access point ARN, you must direct requests to the
+     * access point hostname. The access point hostname takes the form
+     * <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com.
+     * When using this action with an access point through the Amazon Web Services
+     * SDKs, you provide the access point ARN in place of the bucket name. For more
+     * information about access point ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using
+     * access points</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>Access
+     * points and Object Lambda access points are not supported by directory
+     * buckets.</p>  <p> <b>S3 on Outposts</b> - When you use this action with
+     * Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname.
+     * The S3 on Outposts hostname takes the form <code>
+     * <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>.
+     * When you use this action with S3 on Outposts through the Amazon Web Services
+     * SDKs, you provide the Outposts access point ARN in place of the bucket name. For
+     * more information about S3 on Outposts ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What
+     * is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteObjectRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteObjectRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteObjectRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Key name of the object to delete.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline DeleteObjectRequest& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline DeleteObjectRequest& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline DeleteObjectRequest& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The concatenation of the authentication device's serial number, a space, and
+     * the value that is displayed on your authentication device. Required to
+     * permanently delete a versioned object if versioning is configured with MFA
+     * delete enabled.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetMFA() const{ return m_mFA; }
+    inline bool MFAHasBeenSet() const { return m_mFAHasBeenSet; }
+    inline void SetMFA(const Aws::String& value) { m_mFAHasBeenSet = true; m_mFA = value; }
+    inline void SetMFA(Aws::String&& value) { m_mFAHasBeenSet = true; m_mFA = std::move(value); }
+    inline void SetMFA(const char* value) { m_mFAHasBeenSet = true; m_mFA.assign(value); }
+    inline DeleteObjectRequest& WithMFA(const Aws::String& value) { SetMFA(value); return *this;}
+    inline DeleteObjectRequest& WithMFA(Aws::String&& value) { SetMFA(std::move(value)); return *this;}
+    inline DeleteObjectRequest& WithMFA(const char* value) { SetMFA(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Version ID used to reference a specific version of the object.</p> 
+     * <p>For directory buckets in this API operation, only the <code>null</code> value
+     * of the version ID is supported.</p> 
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
+    inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
+    inline DeleteObjectRequest& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline DeleteObjectRequest& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline DeleteObjectRequest& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestPayer& GetRequestPayer() const{ return m_requestPayer; }
+    inline bool RequestPayerHasBeenSet() const { return m_requestPayerHasBeenSet; }
+    inline void SetRequestPayer(const RequestPayer& value) { m_requestPayerHasBeenSet = true; m_requestPayer = value; }
+    inline void SetRequestPayer(RequestPayer&& value) { m_requestPayerHasBeenSet = true; m_requestPayer = std::move(value); }
+    inline DeleteObjectRequest& WithRequestPayer(const RequestPayer& value) { SetRequestPayer(value); return *this;}
+    inline DeleteObjectRequest& WithRequestPayer(RequestPayer&& value) { SetRequestPayer(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates whether S3 Object Lock should bypass Governance-mode restrictions
+     * to process this operation. To use this header, you must have the
+     * <code>s3:BypassGovernanceRetention</code> permission.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline bool GetBypassGovernanceRetention() const{ return m_bypassGovernanceRetention; }
+    inline bool BypassGovernanceRetentionHasBeenSet() const { return m_bypassGovernanceRetentionHasBeenSet; }
+    inline void SetBypassGovernanceRetention(bool value) { m_bypassGovernanceRetentionHasBeenSet = true; m_bypassGovernanceRetention = value; }
+    inline DeleteObjectRequest& WithBypassGovernanceRetention(bool value) { SetBypassGovernanceRetention(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteObjectRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteObjectRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteObjectRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteObjectRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteObjectRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteObjectRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_mFA;
+    bool m_mFAHasBeenSet = false;
+
+    Aws::String m_versionId;
+    bool m_versionIdHasBeenSet = false;
+
+    RequestPayer m_requestPayer;
+    bool m_requestPayerHasBeenSet = false;
+
+    bool m_bypassGovernanceRetention;
+    bool m_bypassGovernanceRetentionHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteObjectResult.h

@@ -0,0 +1,96 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/RequestCharged.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class DeleteObjectResult
+  {
+  public:
+    AWS_S3_API DeleteObjectResult();
+    AWS_S3_API DeleteObjectResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API DeleteObjectResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>Indicates whether the specified object version that was permanently deleted
+     * was (true) or was not (false) a delete marker before deletion. In a simple
+     * DELETE, this header indicates whether (true) or not (false) the current version
+     * of the object is a delete marker.</p>  <p>This functionality is not
+     * supported for directory buckets.</p> 
+     */
+    inline bool GetDeleteMarker() const{ return m_deleteMarker; }
+    inline void SetDeleteMarker(bool value) { m_deleteMarker = value; }
+    inline DeleteObjectResult& WithDeleteMarker(bool value) { SetDeleteMarker(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Returns the version ID of the delete marker created as a result of the DELETE
+     * operation.</p>  <p>This functionality is not supported for directory
+     * buckets.</p> 
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline void SetVersionId(const Aws::String& value) { m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionId.assign(value); }
+    inline DeleteObjectResult& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline DeleteObjectResult& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline DeleteObjectResult& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestCharged& GetRequestCharged() const{ return m_requestCharged; }
+    inline void SetRequestCharged(const RequestCharged& value) { m_requestCharged = value; }
+    inline void SetRequestCharged(RequestCharged&& value) { m_requestCharged = std::move(value); }
+    inline DeleteObjectResult& WithRequestCharged(const RequestCharged& value) { SetRequestCharged(value); return *this;}
+    inline DeleteObjectResult& WithRequestCharged(RequestCharged&& value) { SetRequestCharged(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline DeleteObjectResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline DeleteObjectResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline DeleteObjectResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    bool m_deleteMarker;
+
+    Aws::String m_versionId;
+
+    RequestCharged m_requestCharged;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteObjectTaggingRequest.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteObjectTaggingRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteObjectTaggingRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteObjectTagging"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name containing the objects from which to remove the tags. </p>
+     * <p> <b>Access points</b> - When you use this action with an access point, you
+     * must provide the alias of the access point in place of the bucket name or
+     * specify the access point ARN. When using the access point ARN, you must direct
+     * requests to the access point hostname. The access point hostname takes the form
+     * <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com.
+     * When using this action with an access point through the Amazon Web Services
+     * SDKs, you provide the access point ARN in place of the bucket name. For more
+     * information about access point ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using
+     * access points</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>S3 on
+     * Outposts</b> - When you use this action with Amazon S3 on Outposts, you must
+     * direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname
+     * takes the form <code>
+     * <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>.
+     * When you use this action with S3 on Outposts through the Amazon Web Services
+     * SDKs, you provide the Outposts access point ARN in place of the bucket name. For
+     * more information about S3 on Outposts ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What
+     * is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteObjectTaggingRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteObjectTaggingRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteObjectTaggingRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The key that identifies the object in the bucket from which to remove all
+     * tags.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline DeleteObjectTaggingRequest& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline DeleteObjectTaggingRequest& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline DeleteObjectTaggingRequest& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The versionId of the object that the tag-set will be removed from.</p>
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
+    inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
+    inline DeleteObjectTaggingRequest& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline DeleteObjectTaggingRequest& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline DeleteObjectTaggingRequest& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteObjectTaggingRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteObjectTaggingRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteObjectTaggingRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteObjectTaggingRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteObjectTaggingRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteObjectTaggingRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_versionId;
+    bool m_versionIdHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteObjectTaggingResult.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class DeleteObjectTaggingResult
+  {
+  public:
+    AWS_S3_API DeleteObjectTaggingResult();
+    AWS_S3_API DeleteObjectTaggingResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API DeleteObjectTaggingResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The versionId of the object the tag-set was removed from.</p>
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline void SetVersionId(const Aws::String& value) { m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionId.assign(value); }
+    inline DeleteObjectTaggingResult& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline DeleteObjectTaggingResult& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline DeleteObjectTaggingResult& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline DeleteObjectTaggingResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline DeleteObjectTaggingResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline DeleteObjectTaggingResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_versionId;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteObjectsRequest.h

@@ -0,0 +1,252 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/Delete.h>
+#include <aws/s3/model/RequestPayer.h>
+#include <aws/s3/model/ChecksumAlgorithm.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeleteObjectsRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeleteObjectsRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeleteObjects"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    AWS_S3_API Aws::String GetChecksumAlgorithmName() const override;
+
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The bucket name containing the objects to delete. </p> <p> <b>Directory
+     * buckets</b> - When you use this operation with a directory bucket, you must use
+     * virtual-hosted-style requests in the format <code>
+     * <i>Bucket_name</i>.s3express-<i>az_id</i>.<i>region</i>.amazonaws.com</code>.
+     * Path-style requests are not supported. Directory bucket names must be unique in
+     * the chosen Availability Zone. Bucket names must follow the format <code>
+     * <i>bucket_base_name</i>--<i>az-id</i>--x-s3</code> (for example, <code>
+     * <i>DOC-EXAMPLE-BUCKET</i>--<i>usw2-az1</i>--x-s3</code>). For information about
+     * bucket naming restrictions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory
+     * bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p> <p> <b>Access
+     * points</b> - When you use this action with an access point, you must provide the
+     * alias of the access point in place of the bucket name or specify the access
+     * point ARN. When using the access point ARN, you must direct requests to the
+     * access point hostname. The access point hostname takes the form
+     * <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com.
+     * When using this action with an access point through the Amazon Web Services
+     * SDKs, you provide the access point ARN in place of the bucket name. For more
+     * information about access point ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using
+     * access points</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>Access
+     * points and Object Lambda access points are not supported by directory
+     * buckets.</p>  <p> <b>S3 on Outposts</b> - When you use this action with
+     * Amazon S3 on Outposts, you must direct requests to the S3 on Outposts hostname.
+     * The S3 on Outposts hostname takes the form <code>
+     * <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>.
+     * When you use this action with S3 on Outposts through the Amazon Web Services
+     * SDKs, you provide the Outposts access point ARN in place of the bucket name. For
+     * more information about S3 on Outposts ARNs, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What
+     * is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeleteObjectsRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeleteObjectsRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeleteObjectsRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Container for the request.</p>
+     */
+    inline const Delete& GetDelete() const{ return m_delete; }
+    inline bool DeleteHasBeenSet() const { return m_deleteHasBeenSet; }
+    inline void SetDelete(const Delete& value) { m_deleteHasBeenSet = true; m_delete = value; }
+    inline void SetDelete(Delete&& value) { m_deleteHasBeenSet = true; m_delete = std::move(value); }
+    inline DeleteObjectsRequest& WithDelete(const Delete& value) { SetDelete(value); return *this;}
+    inline DeleteObjectsRequest& WithDelete(Delete&& value) { SetDelete(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The concatenation of the authentication device's serial number, a space, and
+     * the value that is displayed on your authentication device. Required to
+     * permanently delete a versioned object if versioning is configured with MFA
+     * delete enabled.</p> <p>When performing the <code>DeleteObjects</code> operation
+     * on an MFA delete enabled bucket, which attempts to delete the specified
+     * versioned objects, you must include an MFA token. If you don't provide an MFA
+     * token, the entire request will fail, even if there are non-versioned objects
+     * that you are trying to delete. If you provide an invalid token, whether there
+     * are versioned object keys in the request or not, the entire Multi-Object Delete
+     * request will fail. For information about MFA Delete, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html#MultiFactorAuthenticationDelete">
+     * MFA Delete</a> in the <i>Amazon S3 User Guide</i>.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetMFA() const{ return m_mFA; }
+    inline bool MFAHasBeenSet() const { return m_mFAHasBeenSet; }
+    inline void SetMFA(const Aws::String& value) { m_mFAHasBeenSet = true; m_mFA = value; }
+    inline void SetMFA(Aws::String&& value) { m_mFAHasBeenSet = true; m_mFA = std::move(value); }
+    inline void SetMFA(const char* value) { m_mFAHasBeenSet = true; m_mFA.assign(value); }
+    inline DeleteObjectsRequest& WithMFA(const Aws::String& value) { SetMFA(value); return *this;}
+    inline DeleteObjectsRequest& WithMFA(Aws::String&& value) { SetMFA(std::move(value)); return *this;}
+    inline DeleteObjectsRequest& WithMFA(const char* value) { SetMFA(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const RequestPayer& GetRequestPayer() const{ return m_requestPayer; }
+    inline bool RequestPayerHasBeenSet() const { return m_requestPayerHasBeenSet; }
+    inline void SetRequestPayer(const RequestPayer& value) { m_requestPayerHasBeenSet = true; m_requestPayer = value; }
+    inline void SetRequestPayer(RequestPayer&& value) { m_requestPayerHasBeenSet = true; m_requestPayer = std::move(value); }
+    inline DeleteObjectsRequest& WithRequestPayer(const RequestPayer& value) { SetRequestPayer(value); return *this;}
+    inline DeleteObjectsRequest& WithRequestPayer(RequestPayer&& value) { SetRequestPayer(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specifies whether you want to delete this object even if it has a
+     * Governance-type Object Lock in place. To use this header, you must have the
+     * <code>s3:BypassGovernanceRetention</code> permission.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline bool GetBypassGovernanceRetention() const{ return m_bypassGovernanceRetention; }
+    inline bool BypassGovernanceRetentionHasBeenSet() const { return m_bypassGovernanceRetentionHasBeenSet; }
+    inline void SetBypassGovernanceRetention(bool value) { m_bypassGovernanceRetentionHasBeenSet = true; m_bypassGovernanceRetention = value; }
+    inline DeleteObjectsRequest& WithBypassGovernanceRetention(bool value) { SetBypassGovernanceRetention(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeleteObjectsRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeleteObjectsRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeleteObjectsRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates the algorithm used to create the checksum for the object when you
+     * use the SDK. This header will not provide any additional functionality if you
+     * don't use the SDK. When you send this header, there must be a corresponding
+     * <code>x-amz-checksum-<i>algorithm</i> </code> or <code>x-amz-trailer</code>
+     * header sent. Otherwise, Amazon S3 fails the request with the HTTP status code
+     * <code>400 Bad Request</code>.</p> <p>For the
+     * <code>x-amz-checksum-<i>algorithm</i> </code> header, replace <code>
+     * <i>algorithm</i> </code> with the supported algorithm from the following list:
+     * </p> <ul> <li> <p> <code>CRC32</code> </p> </li> <li> <p> <code>CRC32C</code>
+     * </p> </li> <li> <p> <code>SHA1</code> </p> </li> <li> <p> <code>SHA256</code>
+     * </p> </li> </ul> <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking
+     * object integrity</a> in the <i>Amazon S3 User Guide</i>.</p> <p>If the
+     * individual checksum value you provide through
+     * <code>x-amz-checksum-<i>algorithm</i> </code> doesn't match the checksum
+     * algorithm you set through <code>x-amz-sdk-checksum-algorithm</code>, Amazon S3
+     * ignores any provided <code>ChecksumAlgorithm</code> parameter and uses the
+     * checksum algorithm that matches the provided value in
+     * <code>x-amz-checksum-<i>algorithm</i> </code>.</p> <p>If you provide an
+     * individual checksum, Amazon S3 ignores any provided
+     * <code>ChecksumAlgorithm</code> parameter.</p>
+     */
+    inline const ChecksumAlgorithm& GetChecksumAlgorithm() const{ return m_checksumAlgorithm; }
+    inline bool ChecksumAlgorithmHasBeenSet() const { return m_checksumAlgorithmHasBeenSet; }
+    inline void SetChecksumAlgorithm(const ChecksumAlgorithm& value) { m_checksumAlgorithmHasBeenSet = true; m_checksumAlgorithm = value; }
+    inline void SetChecksumAlgorithm(ChecksumAlgorithm&& value) { m_checksumAlgorithmHasBeenSet = true; m_checksumAlgorithm = std::move(value); }
+    inline DeleteObjectsRequest& WithChecksumAlgorithm(const ChecksumAlgorithm& value) { SetChecksumAlgorithm(value); return *this;}
+    inline DeleteObjectsRequest& WithChecksumAlgorithm(ChecksumAlgorithm&& value) { SetChecksumAlgorithm(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeleteObjectsRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeleteObjectsRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeleteObjectsRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Delete m_delete;
+    bool m_deleteHasBeenSet = false;
+
+    Aws::String m_mFA;
+    bool m_mFAHasBeenSet = false;
+
+    RequestPayer m_requestPayer;
+    bool m_requestPayerHasBeenSet = false;
+
+    bool m_bypassGovernanceRetention;
+    bool m_bypassGovernanceRetentionHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    ChecksumAlgorithm m_checksumAlgorithm;
+    bool m_checksumAlgorithmHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeleteObjectsResult.h

@@ -0,0 +1,99 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/s3/model/RequestCharged.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/DeletedObject.h>
+#include <aws/s3/model/Error.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+  class DeleteObjectsResult
+  {
+  public:
+    AWS_S3_API DeleteObjectsResult();
+    AWS_S3_API DeleteObjectsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_S3_API DeleteObjectsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>Container element for a successful delete. It identifies the object that was
+     * successfully deleted.</p>
+     */
+    inline const Aws::Vector<DeletedObject>& GetDeleted() const{ return m_deleted; }
+    inline void SetDeleted(const Aws::Vector<DeletedObject>& value) { m_deleted = value; }
+    inline void SetDeleted(Aws::Vector<DeletedObject>&& value) { m_deleted = std::move(value); }
+    inline DeleteObjectsResult& WithDeleted(const Aws::Vector<DeletedObject>& value) { SetDeleted(value); return *this;}
+    inline DeleteObjectsResult& WithDeleted(Aws::Vector<DeletedObject>&& value) { SetDeleted(std::move(value)); return *this;}
+    inline DeleteObjectsResult& AddDeleted(const DeletedObject& value) { m_deleted.push_back(value); return *this; }
+    inline DeleteObjectsResult& AddDeleted(DeletedObject&& value) { m_deleted.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    
+    inline const RequestCharged& GetRequestCharged() const{ return m_requestCharged; }
+    inline void SetRequestCharged(const RequestCharged& value) { m_requestCharged = value; }
+    inline void SetRequestCharged(RequestCharged&& value) { m_requestCharged = std::move(value); }
+    inline DeleteObjectsResult& WithRequestCharged(const RequestCharged& value) { SetRequestCharged(value); return *this;}
+    inline DeleteObjectsResult& WithRequestCharged(RequestCharged&& value) { SetRequestCharged(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Container for a failed delete action that describes the object that Amazon S3
+     * attempted to delete and the error it encountered.</p>
+     */
+    inline const Aws::Vector<Error>& GetErrors() const{ return m_errors; }
+    inline void SetErrors(const Aws::Vector<Error>& value) { m_errors = value; }
+    inline void SetErrors(Aws::Vector<Error>&& value) { m_errors = std::move(value); }
+    inline DeleteObjectsResult& WithErrors(const Aws::Vector<Error>& value) { SetErrors(value); return *this;}
+    inline DeleteObjectsResult& WithErrors(Aws::Vector<Error>&& value) { SetErrors(std::move(value)); return *this;}
+    inline DeleteObjectsResult& AddErrors(const Error& value) { m_errors.push_back(value); return *this; }
+    inline DeleteObjectsResult& AddErrors(Error&& value) { m_errors.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestId.assign(value); }
+    inline DeleteObjectsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline DeleteObjectsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline DeleteObjectsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::Vector<DeletedObject> m_deleted;
+
+    RequestCharged m_requestCharged;
+
+    Aws::Vector<Error> m_errors;
+
+    Aws::String m_requestId;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeletePublicAccessBlockRequest.h

@@ -0,0 +1,110 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/S3Request.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Http
+{
+    class URI;
+} //namespace Http
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   */
+  class DeletePublicAccessBlockRequest : public S3Request
+  {
+  public:
+    AWS_S3_API DeletePublicAccessBlockRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DeletePublicAccessBlock"; }
+
+    AWS_S3_API Aws::String SerializePayload() const override;
+
+    AWS_S3_API void AddQueryStringParameters(Aws::Http::URI& uri) const override;
+
+    AWS_S3_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+    AWS_S3_API bool HasEmbeddedError(IOStream &body, const Http::HeaderValueCollection &header) const override;
+    /**
+     * Helper function to collect parameters (configurable and static hardcoded) required for endpoint computation.
+     */
+    AWS_S3_API EndpointParameters GetEndpointContextParams() const override;
+
+    ///@{
+    /**
+     * <p>The Amazon S3 bucket whose <code>PublicAccessBlock</code> configuration you
+     * want to delete. </p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline DeletePublicAccessBlockRequest& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline DeletePublicAccessBlockRequest& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline DeletePublicAccessBlockRequest& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The account ID of the expected bucket owner. If the account ID that you
+     * provide does not match the actual owner of the bucket, the request fails with
+     * the HTTP status code <code>403 Forbidden</code> (access denied).</p>
+     */
+    inline const Aws::String& GetExpectedBucketOwner() const{ return m_expectedBucketOwner; }
+    inline bool ExpectedBucketOwnerHasBeenSet() const { return m_expectedBucketOwnerHasBeenSet; }
+    inline void SetExpectedBucketOwner(const Aws::String& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = value; }
+    inline void SetExpectedBucketOwner(Aws::String&& value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner = std::move(value); }
+    inline void SetExpectedBucketOwner(const char* value) { m_expectedBucketOwnerHasBeenSet = true; m_expectedBucketOwner.assign(value); }
+    inline DeletePublicAccessBlockRequest& WithExpectedBucketOwner(const Aws::String& value) { SetExpectedBucketOwner(value); return *this;}
+    inline DeletePublicAccessBlockRequest& WithExpectedBucketOwner(Aws::String&& value) { SetExpectedBucketOwner(std::move(value)); return *this;}
+    inline DeletePublicAccessBlockRequest& WithExpectedBucketOwner(const char* value) { SetExpectedBucketOwner(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const Aws::Map<Aws::String, Aws::String>& GetCustomizedAccessLogTag() const{ return m_customizedAccessLogTag; }
+    inline bool CustomizedAccessLogTagHasBeenSet() const { return m_customizedAccessLogTagHasBeenSet; }
+    inline void SetCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = value; }
+    inline void SetCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag = std::move(value); }
+    inline DeletePublicAccessBlockRequest& WithCustomizedAccessLogTag(const Aws::Map<Aws::String, Aws::String>& value) { SetCustomizedAccessLogTag(value); return *this;}
+    inline DeletePublicAccessBlockRequest& WithCustomizedAccessLogTag(Aws::Map<Aws::String, Aws::String>&& value) { SetCustomizedAccessLogTag(std::move(value)); return *this;}
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(const Aws::String& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(Aws::String&& key, const Aws::String& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(const Aws::String& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(Aws::String&& key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), std::move(value)); return *this; }
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(const char* key, Aws::String&& value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, std::move(value)); return *this; }
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(Aws::String&& key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(std::move(key), value); return *this; }
+    inline DeletePublicAccessBlockRequest& AddCustomizedAccessLogTag(const char* key, const char* value) { m_customizedAccessLogTagHasBeenSet = true; m_customizedAccessLogTag.emplace(key, value); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_expectedBucketOwner;
+    bool m_expectedBucketOwnerHasBeenSet = false;
+
+    Aws::Map<Aws::String, Aws::String> m_customizedAccessLogTag;
+    bool m_customizedAccessLogTagHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/DeletedObject.h

@@ -0,0 +1,116 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Information about the deleted object.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/DeletedObject">AWS
+   * API Reference</a></p>
+   */
+  class DeletedObject
+  {
+  public:
+    AWS_S3_API DeletedObject();
+    AWS_S3_API DeletedObject(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API DeletedObject& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The name of the deleted object.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline DeletedObject& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline DeletedObject& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline DeletedObject& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The version ID of the deleted object.</p>  <p>This functionality is not
+     * supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
+    inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
+    inline DeletedObject& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline DeletedObject& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline DeletedObject& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indicates whether the specified object version that was permanently deleted
+     * was (true) or was not (false) a delete marker before deletion. In a simple
+     * DELETE, this header indicates whether (true) or not (false) the current version
+     * of the object is a delete marker.</p>  <p>This functionality is not
+     * supported for directory buckets.</p> 
+     */
+    inline bool GetDeleteMarker() const{ return m_deleteMarker; }
+    inline bool DeleteMarkerHasBeenSet() const { return m_deleteMarkerHasBeenSet; }
+    inline void SetDeleteMarker(bool value) { m_deleteMarkerHasBeenSet = true; m_deleteMarker = value; }
+    inline DeletedObject& WithDeleteMarker(bool value) { SetDeleteMarker(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The version ID of the delete marker created as a result of the DELETE
+     * operation. If you delete a specific object version, the value returned by this
+     * header is the version ID of the object version deleted.</p>  <p>This
+     * functionality is not supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetDeleteMarkerVersionId() const{ return m_deleteMarkerVersionId; }
+    inline bool DeleteMarkerVersionIdHasBeenSet() const { return m_deleteMarkerVersionIdHasBeenSet; }
+    inline void SetDeleteMarkerVersionId(const Aws::String& value) { m_deleteMarkerVersionIdHasBeenSet = true; m_deleteMarkerVersionId = value; }
+    inline void SetDeleteMarkerVersionId(Aws::String&& value) { m_deleteMarkerVersionIdHasBeenSet = true; m_deleteMarkerVersionId = std::move(value); }
+    inline void SetDeleteMarkerVersionId(const char* value) { m_deleteMarkerVersionIdHasBeenSet = true; m_deleteMarkerVersionId.assign(value); }
+    inline DeletedObject& WithDeleteMarkerVersionId(const Aws::String& value) { SetDeleteMarkerVersionId(value); return *this;}
+    inline DeletedObject& WithDeleteMarkerVersionId(Aws::String&& value) { SetDeleteMarkerVersionId(std::move(value)); return *this;}
+    inline DeletedObject& WithDeleteMarkerVersionId(const char* value) { SetDeleteMarkerVersionId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_versionId;
+    bool m_versionIdHasBeenSet = false;
+
+    bool m_deleteMarker;
+    bool m_deleteMarkerHasBeenSet = false;
+
+    Aws::String m_deleteMarkerVersionId;
+    bool m_deleteMarkerVersionIdHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Destination.h

@@ -0,0 +1,183 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/s3/model/StorageClass.h>
+#include <aws/s3/model/AccessControlTranslation.h>
+#include <aws/s3/model/EncryptionConfiguration.h>
+#include <aws/s3/model/ReplicationTime.h>
+#include <aws/s3/model/Metrics.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies information about where to publish analysis or configuration
+   * results for an Amazon S3 bucket and S3 Replication Time Control (S3
+   * RTC).</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Destination">AWS API
+   * Reference</a></p>
+   */
+  class Destination
+  {
+  public:
+    AWS_S3_API Destination();
+    AWS_S3_API Destination(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Destination& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p> The Amazon Resource Name (ARN) of the bucket where you want Amazon S3 to
+     * store the results.</p>
+     */
+    inline const Aws::String& GetBucket() const{ return m_bucket; }
+    inline bool BucketHasBeenSet() const { return m_bucketHasBeenSet; }
+    inline void SetBucket(const Aws::String& value) { m_bucketHasBeenSet = true; m_bucket = value; }
+    inline void SetBucket(Aws::String&& value) { m_bucketHasBeenSet = true; m_bucket = std::move(value); }
+    inline void SetBucket(const char* value) { m_bucketHasBeenSet = true; m_bucket.assign(value); }
+    inline Destination& WithBucket(const Aws::String& value) { SetBucket(value); return *this;}
+    inline Destination& WithBucket(Aws::String&& value) { SetBucket(std::move(value)); return *this;}
+    inline Destination& WithBucket(const char* value) { SetBucket(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Destination bucket owner account ID. In a cross-account scenario, if you
+     * direct Amazon S3 to change replica ownership to the Amazon Web Services account
+     * that owns the destination bucket by specifying the
+     * <code>AccessControlTranslation</code> property, this is the account ID of the
+     * destination bucket owner. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-change-owner.html">Replication
+     * Additional Configuration: Changing the Replica Owner</a> in the <i>Amazon S3
+     * User Guide</i>.</p>
+     */
+    inline const Aws::String& GetAccount() const{ return m_account; }
+    inline bool AccountHasBeenSet() const { return m_accountHasBeenSet; }
+    inline void SetAccount(const Aws::String& value) { m_accountHasBeenSet = true; m_account = value; }
+    inline void SetAccount(Aws::String&& value) { m_accountHasBeenSet = true; m_account = std::move(value); }
+    inline void SetAccount(const char* value) { m_accountHasBeenSet = true; m_account.assign(value); }
+    inline Destination& WithAccount(const Aws::String& value) { SetAccount(value); return *this;}
+    inline Destination& WithAccount(Aws::String&& value) { SetAccount(std::move(value)); return *this;}
+    inline Destination& WithAccount(const char* value) { SetAccount(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> The storage class to use when replicating objects, such as S3 Standard or
+     * reduced redundancy. By default, Amazon S3 uses the storage class of the source
+     * object to create the object replica. </p> <p>For valid values, see the
+     * <code>StorageClass</code> element of the <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTreplication.html">PUT
+     * Bucket replication</a> action in the <i>Amazon S3 API Reference</i>.</p>
+     */
+    inline const StorageClass& GetStorageClass() const{ return m_storageClass; }
+    inline bool StorageClassHasBeenSet() const { return m_storageClassHasBeenSet; }
+    inline void SetStorageClass(const StorageClass& value) { m_storageClassHasBeenSet = true; m_storageClass = value; }
+    inline void SetStorageClass(StorageClass&& value) { m_storageClassHasBeenSet = true; m_storageClass = std::move(value); }
+    inline Destination& WithStorageClass(const StorageClass& value) { SetStorageClass(value); return *this;}
+    inline Destination& WithStorageClass(StorageClass&& value) { SetStorageClass(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Specify this only in a cross-account scenario (where source and destination
+     * bucket owners are not the same), and you want to change replica ownership to the
+     * Amazon Web Services account that owns the destination bucket. If this is not
+     * specified in the replication configuration, the replicas are owned by same
+     * Amazon Web Services account that owns the source object.</p>
+     */
+    inline const AccessControlTranslation& GetAccessControlTranslation() const{ return m_accessControlTranslation; }
+    inline bool AccessControlTranslationHasBeenSet() const { return m_accessControlTranslationHasBeenSet; }
+    inline void SetAccessControlTranslation(const AccessControlTranslation& value) { m_accessControlTranslationHasBeenSet = true; m_accessControlTranslation = value; }
+    inline void SetAccessControlTranslation(AccessControlTranslation&& value) { m_accessControlTranslationHasBeenSet = true; m_accessControlTranslation = std::move(value); }
+    inline Destination& WithAccessControlTranslation(const AccessControlTranslation& value) { SetAccessControlTranslation(value); return *this;}
+    inline Destination& WithAccessControlTranslation(AccessControlTranslation&& value) { SetAccessControlTranslation(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A container that provides information about encryption. If
+     * <code>SourceSelectionCriteria</code> is specified, you must specify this
+     * element.</p>
+     */
+    inline const EncryptionConfiguration& GetEncryptionConfiguration() const{ return m_encryptionConfiguration; }
+    inline bool EncryptionConfigurationHasBeenSet() const { return m_encryptionConfigurationHasBeenSet; }
+    inline void SetEncryptionConfiguration(const EncryptionConfiguration& value) { m_encryptionConfigurationHasBeenSet = true; m_encryptionConfiguration = value; }
+    inline void SetEncryptionConfiguration(EncryptionConfiguration&& value) { m_encryptionConfigurationHasBeenSet = true; m_encryptionConfiguration = std::move(value); }
+    inline Destination& WithEncryptionConfiguration(const EncryptionConfiguration& value) { SetEncryptionConfiguration(value); return *this;}
+    inline Destination& WithEncryptionConfiguration(EncryptionConfiguration&& value) { SetEncryptionConfiguration(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> A container specifying S3 Replication Time Control (S3 RTC), including
+     * whether S3 RTC is enabled and the time when all objects and operations on
+     * objects must be replicated. Must be specified together with a
+     * <code>Metrics</code> block. </p>
+     */
+    inline const ReplicationTime& GetReplicationTime() const{ return m_replicationTime; }
+    inline bool ReplicationTimeHasBeenSet() const { return m_replicationTimeHasBeenSet; }
+    inline void SetReplicationTime(const ReplicationTime& value) { m_replicationTimeHasBeenSet = true; m_replicationTime = value; }
+    inline void SetReplicationTime(ReplicationTime&& value) { m_replicationTimeHasBeenSet = true; m_replicationTime = std::move(value); }
+    inline Destination& WithReplicationTime(const ReplicationTime& value) { SetReplicationTime(value); return *this;}
+    inline Destination& WithReplicationTime(ReplicationTime&& value) { SetReplicationTime(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> A container specifying replication metrics-related settings enabling
+     * replication metrics and events. </p>
+     */
+    inline const Metrics& GetMetrics() const{ return m_metrics; }
+    inline bool MetricsHasBeenSet() const { return m_metricsHasBeenSet; }
+    inline void SetMetrics(const Metrics& value) { m_metricsHasBeenSet = true; m_metrics = value; }
+    inline void SetMetrics(Metrics&& value) { m_metricsHasBeenSet = true; m_metrics = std::move(value); }
+    inline Destination& WithMetrics(const Metrics& value) { SetMetrics(value); return *this;}
+    inline Destination& WithMetrics(Metrics&& value) { SetMetrics(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_bucket;
+    bool m_bucketHasBeenSet = false;
+
+    Aws::String m_account;
+    bool m_accountHasBeenSet = false;
+
+    StorageClass m_storageClass;
+    bool m_storageClassHasBeenSet = false;
+
+    AccessControlTranslation m_accessControlTranslation;
+    bool m_accessControlTranslationHasBeenSet = false;
+
+    EncryptionConfiguration m_encryptionConfiguration;
+    bool m_encryptionConfigurationHasBeenSet = false;
+
+    ReplicationTime m_replicationTime;
+    bool m_replicationTimeHasBeenSet = false;
+
+    Metrics m_metrics;
+    bool m_metricsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/EncodingType.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class EncodingType
+  {
+    NOT_SET,
+    url
+  };
+
+namespace EncodingTypeMapper
+{
+AWS_S3_API EncodingType GetEncodingTypeForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForEncodingType(EncodingType value);
+} // namespace EncodingTypeMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Encryption.h

@@ -0,0 +1,102 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/ServerSideEncryption.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains the type of server-side encryption used.</p><p><h3>See Also:</h3>  
+   * <a href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Encryption">AWS
+   * API Reference</a></p>
+   */
+  class Encryption
+  {
+  public:
+    AWS_S3_API Encryption();
+    AWS_S3_API Encryption(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Encryption& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The server-side encryption algorithm used when storing job results in Amazon
+     * S3 (for example, AES256, <code>aws:kms</code>).</p>
+     */
+    inline const ServerSideEncryption& GetEncryptionType() const{ return m_encryptionType; }
+    inline bool EncryptionTypeHasBeenSet() const { return m_encryptionTypeHasBeenSet; }
+    inline void SetEncryptionType(const ServerSideEncryption& value) { m_encryptionTypeHasBeenSet = true; m_encryptionType = value; }
+    inline void SetEncryptionType(ServerSideEncryption&& value) { m_encryptionTypeHasBeenSet = true; m_encryptionType = std::move(value); }
+    inline Encryption& WithEncryptionType(const ServerSideEncryption& value) { SetEncryptionType(value); return *this;}
+    inline Encryption& WithEncryptionType(ServerSideEncryption&& value) { SetEncryptionType(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If the encryption type is <code>aws:kms</code>, this optional value specifies
+     * the ID of the symmetric encryption customer managed key to use for encryption of
+     * job results. Amazon S3 only supports symmetric encryption KMS keys. For more
+     * information, see <a
+     * href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric
+     * keys in KMS</a> in the <i>Amazon Web Services Key Management Service Developer
+     * Guide</i>.</p>
+     */
+    inline const Aws::String& GetKMSKeyId() const{ return m_kMSKeyId; }
+    inline bool KMSKeyIdHasBeenSet() const { return m_kMSKeyIdHasBeenSet; }
+    inline void SetKMSKeyId(const Aws::String& value) { m_kMSKeyIdHasBeenSet = true; m_kMSKeyId = value; }
+    inline void SetKMSKeyId(Aws::String&& value) { m_kMSKeyIdHasBeenSet = true; m_kMSKeyId = std::move(value); }
+    inline void SetKMSKeyId(const char* value) { m_kMSKeyIdHasBeenSet = true; m_kMSKeyId.assign(value); }
+    inline Encryption& WithKMSKeyId(const Aws::String& value) { SetKMSKeyId(value); return *this;}
+    inline Encryption& WithKMSKeyId(Aws::String&& value) { SetKMSKeyId(std::move(value)); return *this;}
+    inline Encryption& WithKMSKeyId(const char* value) { SetKMSKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>If the encryption type is <code>aws:kms</code>, this optional value can be
+     * used to specify the encryption context for the restore results.</p>
+     */
+    inline const Aws::String& GetKMSContext() const{ return m_kMSContext; }
+    inline bool KMSContextHasBeenSet() const { return m_kMSContextHasBeenSet; }
+    inline void SetKMSContext(const Aws::String& value) { m_kMSContextHasBeenSet = true; m_kMSContext = value; }
+    inline void SetKMSContext(Aws::String&& value) { m_kMSContextHasBeenSet = true; m_kMSContext = std::move(value); }
+    inline void SetKMSContext(const char* value) { m_kMSContextHasBeenSet = true; m_kMSContext.assign(value); }
+    inline Encryption& WithKMSContext(const Aws::String& value) { SetKMSContext(value); return *this;}
+    inline Encryption& WithKMSContext(Aws::String&& value) { SetKMSContext(std::move(value)); return *this;}
+    inline Encryption& WithKMSContext(const char* value) { SetKMSContext(value); return *this;}
+    ///@}
+  private:
+
+    ServerSideEncryption m_encryptionType;
+    bool m_encryptionTypeHasBeenSet = false;
+
+    Aws::String m_kMSKeyId;
+    bool m_kMSKeyIdHasBeenSet = false;
+
+    Aws::String m_kMSContext;
+    bool m_kMSContextHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/EncryptionConfiguration.h

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Specifies encryption-related information for an Amazon S3 bucket that is a
+   * destination for replicated objects.</p>  <p>If you're specifying a
+   * customer managed KMS key, we recommend using a fully qualified KMS key ARN. If
+   * you use a KMS key alias instead, then KMS resolves the key within the
+   * requester’s account. This behavior can result in data that's encrypted with a
+   * KMS key that belongs to the requester, and not the bucket owner.</p>
+   * <p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/EncryptionConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class EncryptionConfiguration
+  {
+  public:
+    AWS_S3_API EncryptionConfiguration();
+    AWS_S3_API EncryptionConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API EncryptionConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies the ID (Key ARN or Alias ARN) of the customer managed Amazon Web
+     * Services KMS key stored in Amazon Web Services Key Management Service (KMS) for
+     * the destination bucket. Amazon S3 uses this key to encrypt replica objects.
+     * Amazon S3 only supports symmetric encryption KMS keys. For more information, see
+     * <a
+     * href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Asymmetric
+     * keys in Amazon Web Services KMS</a> in the <i>Amazon Web Services Key Management
+     * Service Developer Guide</i>.</p>
+     */
+    inline const Aws::String& GetReplicaKmsKeyID() const{ return m_replicaKmsKeyID; }
+    inline bool ReplicaKmsKeyIDHasBeenSet() const { return m_replicaKmsKeyIDHasBeenSet; }
+    inline void SetReplicaKmsKeyID(const Aws::String& value) { m_replicaKmsKeyIDHasBeenSet = true; m_replicaKmsKeyID = value; }
+    inline void SetReplicaKmsKeyID(Aws::String&& value) { m_replicaKmsKeyIDHasBeenSet = true; m_replicaKmsKeyID = std::move(value); }
+    inline void SetReplicaKmsKeyID(const char* value) { m_replicaKmsKeyIDHasBeenSet = true; m_replicaKmsKeyID.assign(value); }
+    inline EncryptionConfiguration& WithReplicaKmsKeyID(const Aws::String& value) { SetReplicaKmsKeyID(value); return *this;}
+    inline EncryptionConfiguration& WithReplicaKmsKeyID(Aws::String&& value) { SetReplicaKmsKeyID(std::move(value)); return *this;}
+    inline EncryptionConfiguration& WithReplicaKmsKeyID(const char* value) { SetReplicaKmsKeyID(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_replicaKmsKeyID;
+    bool m_replicaKmsKeyIDHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Error.h

@@ -0,0 +1,480 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Container for all error elements.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/Error">AWS API
+   * Reference</a></p>
+   */
+  class Error
+  {
+  public:
+    AWS_S3_API Error();
+    AWS_S3_API Error(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API Error& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The error key.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline Error& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline Error& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline Error& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The version ID of the error.</p>  <p>This functionality is not
+     * supported for directory buckets.</p> 
+     */
+    inline const Aws::String& GetVersionId() const{ return m_versionId; }
+    inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
+    inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
+    inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
+    inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
+    inline Error& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
+    inline Error& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
+    inline Error& WithVersionId(const char* value) { SetVersionId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition. It is
+     * meant to be read and understood by programs that detect and handle errors by
+     * type. The following is a list of Amazon S3 error codes. For more information,
+     * see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html">Error
+     * responses</a>.</p> <ul> <li> <ul> <li> <p> <i>Code:</i> AccessDenied </p> </li>
+     * <li> <p> <i>Description:</i> Access Denied</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 403 Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> AccountProblem</p>
+     * </li> <li> <p> <i>Description:</i> There is a problem with your Amazon Web
+     * Services account that prevents the action from completing successfully. Contact
+     * Amazon Web Services Support for further assistance.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 403 Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * AllAccessDisabled</p> </li> <li> <p> <i>Description:</i> All access to this
+     * Amazon S3 resource has been disabled. Contact Amazon Web Services Support for
+     * further assistance.</p> </li> <li> <p> <i>HTTP Status Code:</i> 403
+     * Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> AmbiguousGrantByEmailAddress</p>
+     * </li> <li> <p> <i>Description:</i> The email address you provided is associated
+     * with more than one account.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> AuthorizationHeaderMalformed</p> </li>
+     * <li> <p> <i>Description:</i> The authorization header you provided is
+     * invalid.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li>
+     * <li> <p> <i>HTTP Status Code:</i> N/A</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> BadDigest</p> </li> <li> <p> <i>Description:</i> The Content-MD5
+     * you specified did not match what we received.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * BucketAlreadyExists</p> </li> <li> <p> <i>Description:</i> The requested bucket
+     * name is not available. The bucket namespace is shared by all users of the
+     * system. Please select a different name and try again.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 409 Conflict</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * BucketAlreadyOwnedByYou</p> </li> <li> <p> <i>Description:</i> The bucket you
+     * tried to create already exists, and you own it. Amazon S3 returns this error in
+     * all Amazon Web Services Regions except in the North Virginia Region. For legacy
+     * compatibility, if you re-create an existing bucket that you already own in the
+     * North Virginia Region, Amazon S3 returns 200 OK and resets the bucket access
+     * control lists (ACLs).</p> </li> <li> <p> <i>Code:</i> 409 Conflict (in all
+     * Regions except the North Virginia Region) </p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * BucketNotEmpty</p> </li> <li> <p> <i>Description:</i> The bucket you tried to
+     * delete is not empty.</p> </li> <li> <p> <i>HTTP Status Code:</i> 409
+     * Conflict</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> CredentialsNotSupported</p> </li>
+     * <li> <p> <i>Description:</i> This request does not support credentials.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p>
+     * <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> CrossLocationLoggingProhibited</p> </li> <li> <p>
+     * <i>Description:</i> Cross-location logging not allowed. Buckets in one
+     * geographic location cannot log information to a bucket in another location.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 403 Forbidden</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> EntityTooSmall</p> </li> <li> <p> <i>Description:</i> Your proposed
+     * upload is smaller than the minimum allowed object size.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * EntityTooLarge</p> </li> <li> <p> <i>Description:</i> Your proposed upload
+     * exceeds the maximum allowed object size.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> ExpiredToken</p>
+     * </li> <li> <p> <i>Description:</i> The provided token has expired.</p> </li>
+     * <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> IllegalVersioningConfigurationException </p> </li> <li> <p>
+     * <i>Description:</i> Indicates that the versioning configuration specified in the
+     * request is invalid.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> IncompleteBody</p> </li> <li> <p>
+     * <i>Description:</i> You did not provide the number of bytes specified by the
+     * Content-Length HTTP header</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> IncorrectNumberOfFilesInPostRequest</p>
+     * </li> <li> <p> <i>Description:</i> POST requires exactly one file upload per
+     * request.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li>
+     * <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul>
+     * <li> <p> <i>Code:</i> InlineDataTooLarge</p> </li> <li> <p> <i>Description:</i>
+     * Inline data exceeds the maximum allowed size.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InternalError</p>
+     * </li> <li> <p> <i>Description:</i> We encountered an internal error. Please try
+     * again.</p> </li> <li> <p> <i>HTTP Status Code:</i> 500 Internal Server Error</p>
+     * </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Server</p> </li> </ul> </li> <li>
+     * <ul> <li> <p> <i>Code:</i> InvalidAccessKeyId</p> </li> <li> <p>
+     * <i>Description:</i> The Amazon Web Services access key ID you provided does not
+     * exist in our records.</p> </li> <li> <p> <i>HTTP Status Code:</i> 403
+     * Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidAddressingHeader</p> </li>
+     * <li> <p> <i>Description:</i> You must specify the Anonymous role.</p> </li> <li>
+     * <p> <i>HTTP Status Code:</i> N/A</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidArgument</p> </li> <li> <p> <i>Description:</i> Invalid Argument</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p>
+     * <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> InvalidBucketName</p> </li> <li> <p> <i>Description:</i> The
+     * specified bucket is not valid.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400
+     * Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidBucketState</p> </li> <li>
+     * <p> <i>Description:</i> The request is not valid with the current state of the
+     * bucket.</p> </li> <li> <p> <i>HTTP Status Code:</i> 409 Conflict</p> </li> <li>
+     * <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li>
+     * <p> <i>Code:</i> InvalidDigest</p> </li> <li> <p> <i>Description:</i> The
+     * Content-MD5 you specified is not valid.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidEncryptionAlgorithmError</p> </li> <li> <p> <i>Description:</i> The
+     * encryption request you specified is not valid. The valid value is AES256.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p>
+     * <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> InvalidLocationConstraint</p> </li> <li> <p> <i>Description:</i>
+     * The specified location constraint is not valid. For more information about
+     * Regions, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro">How
+     * to Select a Region for Your Buckets</a>. </p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidObjectState</p> </li> <li> <p> <i>Description:</i> The action is not
+     * valid for the current state of the object.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 403 Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidPart</p>
+     * </li> <li> <p> <i>Description:</i> One or more of the specified parts could not
+     * be found. The part might not have been uploaded, or the specified entity tag
+     * might not have matched the part's entity tag.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidPartOrder</p> </li> <li> <p> <i>Description:</i> The list of parts was
+     * not in ascending order. Parts list must be specified in order by part
+     * number.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li>
+     * <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul>
+     * <li> <p> <i>Code:</i> InvalidPayer</p> </li> <li> <p> <i>Description:</i> All
+     * access to this object has been disabled. Please contact Amazon Web Services
+     * Support for further assistance.</p> </li> <li> <p> <i>HTTP Status Code:</i> 403
+     * Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidPolicyDocument</p> </li> <li>
+     * <p> <i>Description:</i> The content of the form does not meet the conditions
+     * specified in the policy document.</p> </li> <li> <p> <i>HTTP Status Code:</i>
+     * 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p>
+     * </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidRange</p> </li> <li>
+     * <p> <i>Description:</i> The requested range cannot be satisfied.</p> </li> <li>
+     * <p> <i>HTTP Status Code:</i> 416 Requested Range Not Satisfiable</p> </li> <li>
+     * <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li>
+     * <p> <i>Code:</i> InvalidRequest</p> </li> <li> <p> <i>Description:</i> Please
+     * use <code>AWS4-HMAC-SHA256</code>.</p> </li> <li> <p> <i>HTTP Status Code:</i>
+     * 400 Bad Request</p> </li> <li> <p> <i>Code:</i> N/A</p> </li> </ul> </li> <li>
+     * <ul> <li> <p> <i>Code:</i> InvalidRequest</p> </li> <li> <p> <i>Description:</i>
+     * SOAP requests must be made over an HTTPS connection.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidRequest</p> </li> <li> <p> <i>Description:</i> Amazon S3 Transfer
+     * Acceleration is not supported for buckets with non-DNS compliant names.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p>
+     * <i>Code:</i> N/A</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidRequest</p> </li> <li> <p> <i>Description:</i> Amazon S3 Transfer
+     * Acceleration is not supported for buckets with periods (.) in their names.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p>
+     * <i>Code:</i> N/A</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidRequest</p> </li> <li> <p> <i>Description:</i> Amazon S3 Transfer
+     * Accelerate endpoint only supports virtual style requests.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>Code:</i> N/A</p>
+     * </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidRequest</p> </li> <li>
+     * <p> <i>Description:</i> Amazon S3 Transfer Accelerate is not configured on this
+     * bucket.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li>
+     * <li> <p> <i>Code:</i> N/A</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidRequest</p> </li> <li> <p> <i>Description:</i> Amazon S3 Transfer
+     * Accelerate is disabled on this bucket.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>Code:</i> N/A</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> InvalidRequest</p> </li> <li> <p>
+     * <i>Description:</i> Amazon S3 Transfer Acceleration is not supported on this
+     * bucket. Contact Amazon Web Services Support for more information.</p> </li> <li>
+     * <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>Code:</i>
+     * N/A</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidRequest</p>
+     * </li> <li> <p> <i>Description:</i> Amazon S3 Transfer Acceleration cannot be
+     * enabled on this bucket. Contact Amazon Web Services Support for more
+     * information.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p>
+     * </li> <li> <p> <i>Code:</i> N/A</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> InvalidSecurity</p> </li> <li> <p> <i>Description:</i> The provided
+     * security credentials are not valid.</p> </li> <li> <p> <i>HTTP Status Code:</i>
+     * 403 Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> InvalidSOAPRequest</p> </li> <li>
+     * <p> <i>Description:</i> The SOAP request body is invalid.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidStorageClass</p> </li> <li> <p> <i>Description:</i> The storage class you
+     * specified is not valid.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> InvalidTargetBucketForLogging</p> </li>
+     * <li> <p> <i>Description:</i> The target bucket for logging does not exist, is
+     * not owned by you, or does not have the appropriate grants for the log-delivery
+     * group. </p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li>
+     * <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul>
+     * <li> <p> <i>Code:</i> InvalidToken</p> </li> <li> <p> <i>Description:</i> The
+     * provided token is malformed or otherwise invalid.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * InvalidURI</p> </li> <li> <p> <i>Description:</i> Couldn't parse the specified
+     * URI.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li>
+     * <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li>
+     * <p> <i>Code:</i> KeyTooLongError</p> </li> <li> <p> <i>Description:</i> Your key
+     * is too long.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p>
+     * </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li>
+     * <ul> <li> <p> <i>Code:</i> MalformedACLError</p> </li> <li> <p>
+     * <i>Description:</i> The XML you provided was not well-formed or did not validate
+     * against our published schema.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400
+     * Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> MalformedPOSTRequest </p> </li> <li>
+     * <p> <i>Description:</i> The body of your POST request is not well-formed
+     * multipart/form-data.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> MalformedXML</p> </li> <li> <p>
+     * <i>Description:</i> This happens when the user sends malformed XML (XML that
+     * doesn't conform to the published XSD) for the configuration. The error message
+     * is, "The XML you provided was not well-formed or did not validate against our
+     * published schema." </p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> MaxMessageLengthExceeded</p> </li> <li>
+     * <p> <i>Description:</i> Your request was too big.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * MaxPostPreDataLengthExceededError</p> </li> <li> <p> <i>Description:</i> Your
+     * POST request fields preceding the upload file were too large.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * MetadataTooLarge</p> </li> <li> <p> <i>Description:</i> Your metadata headers
+     * exceed the maximum allowed metadata size.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * MethodNotAllowed</p> </li> <li> <p> <i>Description:</i> The specified method is
+     * not allowed against this resource.</p> </li> <li> <p> <i>HTTP Status Code:</i>
+     * 405 Method Not Allowed</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * MissingAttachment</p> </li> <li> <p> <i>Description:</i> A SOAP attachment was
+     * expected, but none were found.</p> </li> <li> <p> <i>HTTP Status Code:</i>
+     * N/A</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> MissingContentLength</p> </li> <li> <p>
+     * <i>Description:</i> You must provide the Content-Length HTTP header.</p> </li>
+     * <li> <p> <i>HTTP Status Code:</i> 411 Length Required</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> MissingRequestBodyError</p> </li> <li> <p> <i>Description:</i> This
+     * happens when the user sends an empty XML document as a request. The error
+     * message is, "Request body is empty." </p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * MissingSecurityElement</p> </li> <li> <p> <i>Description:</i> The SOAP 1.1
+     * request is missing a security element.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * MissingSecurityHeader</p> </li> <li> <p> <i>Description:</i> Your request is
+     * missing a required header.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> NoLoggingStatusForKey</p> </li> <li> <p>
+     * <i>Description:</i> There is no such thing as a logging status subresource for a
+     * key.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li>
+     * <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li>
+     * <p> <i>Code:</i> NoSuchBucket</p> </li> <li> <p> <i>Description:</i> The
+     * specified bucket does not exist.</p> </li> <li> <p> <i>HTTP Status Code:</i> 404
+     * Not Found</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> NoSuchBucketPolicy</p> </li> <li>
+     * <p> <i>Description:</i> The specified bucket does not have a bucket policy.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 404 Not Found</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> NoSuchKey</p> </li> <li> <p> <i>Description:</i> The specified key
+     * does not exist.</p> </li> <li> <p> <i>HTTP Status Code:</i> 404 Not Found</p>
+     * </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li>
+     * <ul> <li> <p> <i>Code:</i> NoSuchLifecycleConfiguration</p> </li> <li> <p>
+     * <i>Description:</i> The lifecycle configuration does not exist. </p> </li> <li>
+     * <p> <i>HTTP Status Code:</i> 404 Not Found</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * NoSuchUpload</p> </li> <li> <p> <i>Description:</i> The specified multipart
+     * upload does not exist. The upload ID might be invalid, or the multipart upload
+     * might have been aborted or completed.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 404 Not Found</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> NoSuchVersion </p>
+     * </li> <li> <p> <i>Description:</i> Indicates that the version ID specified in
+     * the request does not match an existing version.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 404 Not Found</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i> NotImplemented</p>
+     * </li> <li> <p> <i>Description:</i> A header you provided implies functionality
+     * that is not implemented.</p> </li> <li> <p> <i>HTTP Status Code:</i> 501 Not
+     * Implemented</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Server</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> NotSignedUp</p> </li> <li> <p>
+     * <i>Description:</i> Your account is not signed up for the Amazon S3 service. You
+     * must sign up before you can use Amazon S3. You can sign up at the following URL:
+     * <a href="http://aws.amazon.com/s3">Amazon S3</a> </p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 403 Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * OperationAborted</p> </li> <li> <p> <i>Description:</i> A conflicting
+     * conditional action is currently in progress against this resource. Try
+     * again.</p> </li> <li> <p> <i>HTTP Status Code:</i> 409 Conflict</p> </li> <li>
+     * <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li>
+     * <p> <i>Code:</i> PermanentRedirect</p> </li> <li> <p> <i>Description:</i> The
+     * bucket you are attempting to access must be addressed using the specified
+     * endpoint. Send all future requests to this endpoint.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 301 Moved Permanently</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * PreconditionFailed</p> </li> <li> <p> <i>Description:</i> At least one of the
+     * preconditions you specified did not hold.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 412 Precondition Failed</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * Redirect</p> </li> <li> <p> <i>Description:</i> Temporary redirect.</p> </li>
+     * <li> <p> <i>HTTP Status Code:</i> 307 Moved Temporarily</p> </li> <li> <p>
+     * <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> RestoreAlreadyInProgress</p> </li> <li> <p> <i>Description:</i>
+     * Object restore is already in progress.</p> </li> <li> <p> <i>HTTP Status
+     * Code:</i> 409 Conflict</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i>
+     * Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * RequestIsNotMultiPartContent</p> </li> <li> <p> <i>Description:</i> Bucket POST
+     * must be of the enclosure-type multipart/form-data.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * RequestTimeout</p> </li> <li> <p> <i>Description:</i> Your socket connection to
+     * the server was not read from or written to within the timeout period.</p> </li>
+     * <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> RequestTimeTooSkewed</p> </li> <li> <p> <i>Description:</i> The
+     * difference between the request time and the server's time is too large.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 403 Forbidden</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> RequestTorrentOfBucketError</p> </li> <li> <p> <i>Description:</i>
+     * Requesting the torrent file of a bucket is not permitted.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * SignatureDoesNotMatch</p> </li> <li> <p> <i>Description:</i> The request
+     * signature we calculated does not match the signature you provided. Check your
+     * Amazon Web Services secret access key and signing method. For more information,
+     * see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html">REST
+     * Authentication</a> and <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/SOAPAuthentication.html">SOAP
+     * Authentication</a> for details.</p> </li> <li> <p> <i>HTTP Status Code:</i> 403
+     * Forbidden</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li>
+     * </ul> </li> <li> <ul> <li> <p> <i>Code:</i> ServiceUnavailable</p> </li> <li>
+     * <p> <i>Description:</i> Service is unable to handle request.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 503 Service Unavailable</p> </li> <li> <p> <i>SOAP
+     * Fault Code Prefix:</i> Server</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> SlowDown</p> </li> <li> <p> <i>Description:</i> Reduce your request
+     * rate.</p> </li> <li> <p> <i>HTTP Status Code:</i> 503 Slow Down</p> </li> <li>
+     * <p> <i>SOAP Fault Code Prefix:</i> Server</p> </li> </ul> </li> <li> <ul> <li>
+     * <p> <i>Code:</i> TemporaryRedirect</p> </li> <li> <p> <i>Description:</i> You
+     * are being redirected to the bucket while DNS updates.</p> </li> <li> <p> <i>HTTP
+     * Status Code:</i> 307 Moved Temporarily</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * TokenRefreshRequired</p> </li> <li> <p> <i>Description:</i> The provided token
+     * must be refreshed.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad
+     * Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul>
+     * </li> <li> <ul> <li> <p> <i>Code:</i> TooManyBuckets</p> </li> <li> <p>
+     * <i>Description:</i> You have attempted to create more buckets than allowed.</p>
+     * </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p>
+     * <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p>
+     * <i>Code:</i> UnexpectedContent</p> </li> <li> <p> <i>Description:</i> This
+     * request does not support content.</p> </li> <li> <p> <i>HTTP Status Code:</i>
+     * 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p>
+     * </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * UnresolvableGrantByEmailAddress</p> </li> <li> <p> <i>Description:</i> The email
+     * address you provided does not match any account on record.</p> </li> <li> <p>
+     * <i>HTTP Status Code:</i> 400 Bad Request</p> </li> <li> <p> <i>SOAP Fault Code
+     * Prefix:</i> Client</p> </li> </ul> </li> <li> <ul> <li> <p> <i>Code:</i>
+     * UserKeyMustBeSpecified</p> </li> <li> <p> <i>Description:</i> The bucket POST
+     * must contain the specified field name. If it is specified, check the order of
+     * the fields.</p> </li> <li> <p> <i>HTTP Status Code:</i> 400 Bad Request</p>
+     * </li> <li> <p> <i>SOAP Fault Code Prefix:</i> Client</p> </li> </ul> </li> </ul>
+     * <p/>
+     */
+    inline const Aws::String& GetCode() const{ return m_code; }
+    inline bool CodeHasBeenSet() const { return m_codeHasBeenSet; }
+    inline void SetCode(const Aws::String& value) { m_codeHasBeenSet = true; m_code = value; }
+    inline void SetCode(Aws::String&& value) { m_codeHasBeenSet = true; m_code = std::move(value); }
+    inline void SetCode(const char* value) { m_codeHasBeenSet = true; m_code.assign(value); }
+    inline Error& WithCode(const Aws::String& value) { SetCode(value); return *this;}
+    inline Error& WithCode(Aws::String&& value) { SetCode(std::move(value)); return *this;}
+    inline Error& WithCode(const char* value) { SetCode(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The error message contains a generic description of the error condition in
+     * English. It is intended for a human audience. Simple programs display the
+     * message directly to the end user if they encounter an error condition they don't
+     * know how or don't care to handle. Sophisticated programs with more exhaustive
+     * error handling and proper internationalization are more likely to ignore the
+     * error message.</p>
+     */
+    inline const Aws::String& GetMessage() const{ return m_message; }
+    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
+    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }
+    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }
+    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }
+    inline Error& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}
+    inline Error& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}
+    inline Error& WithMessage(const char* value) { SetMessage(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_versionId;
+    bool m_versionIdHasBeenSet = false;
+
+    Aws::String m_code;
+    bool m_codeHasBeenSet = false;
+
+    Aws::String m_message;
+    bool m_messageHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/ErrorDocument.h

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>The error information.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ErrorDocument">AWS
+   * API Reference</a></p>
+   */
+  class ErrorDocument
+  {
+  public:
+    AWS_S3_API ErrorDocument();
+    AWS_S3_API ErrorDocument(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API ErrorDocument& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>The object key name to use when a 4XX class error occurs.</p> 
+     * <p>Replacement must be made for object keys containing special characters (such
+     * as carriage returns) when using XML requests. For more information, see <a
+     * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints">
+     * XML related object key constraints</a>.</p> 
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline ErrorDocument& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline ErrorDocument& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline ErrorDocument& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/Event.h

@@ -0,0 +1,56 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class Event
+  {
+    NOT_SET,
+    s3_ReducedRedundancyLostObject,
+    s3_ObjectCreated,
+    s3_ObjectCreated_Put,
+    s3_ObjectCreated_Post,
+    s3_ObjectCreated_Copy,
+    s3_ObjectCreated_CompleteMultipartUpload,
+    s3_ObjectRemoved,
+    s3_ObjectRemoved_Delete,
+    s3_ObjectRemoved_DeleteMarkerCreated,
+    s3_ObjectRestore,
+    s3_ObjectRestore_Post,
+    s3_ObjectRestore_Completed,
+    s3_Replication,
+    s3_Replication_OperationFailedReplication,
+    s3_Replication_OperationNotTracked,
+    s3_Replication_OperationMissedThreshold,
+    s3_Replication_OperationReplicatedAfterThreshold,
+    s3_ObjectRestore_Delete,
+    s3_LifecycleTransition,
+    s3_IntelligentTiering,
+    s3_ObjectAcl_Put,
+    s3_LifecycleExpiration,
+    s3_LifecycleExpiration_Delete,
+    s3_LifecycleExpiration_DeleteMarkerCreated,
+    s3_ObjectTagging,
+    s3_ObjectTagging_Put,
+    s3_ObjectTagging_Delete
+  };
+
+namespace EventMapper
+{
+AWS_S3_API Event GetEventForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForEvent(Event value);
+} // namespace EventMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/EventBridgeConfiguration.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>A container for specifying the configuration for Amazon
+   * EventBridge.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/EventBridgeConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class EventBridgeConfiguration
+  {
+  public:
+    AWS_S3_API EventBridgeConfiguration();
+    AWS_S3_API EventBridgeConfiguration(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API EventBridgeConfiguration& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/ExistingObjectReplication.h

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/s3/model/ExistingObjectReplicationStatus.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace S3
+{
+namespace Model
+{
+
+  /**
+   * <p>Optional configuration to replicate existing source bucket objects. </p>
+   *  <p>This parameter is no longer supported. To replicate existing objects,
+   * see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-batch-replication-batch.html">Replicating
+   * existing objects with S3 Batch Replication</a> in the <i>Amazon S3 User
+   * Guide</i>.</p> <p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/s3-2006-03-01/ExistingObjectReplication">AWS
+   * API Reference</a></p>
+   */
+  class ExistingObjectReplication
+  {
+  public:
+    AWS_S3_API ExistingObjectReplication();
+    AWS_S3_API ExistingObjectReplication(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_S3_API ExistingObjectReplication& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_S3_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
+
+
+    ///@{
+    /**
+     * <p>Specifies whether Amazon S3 replicates existing source bucket objects. </p>
+     */
+    inline const ExistingObjectReplicationStatus& GetStatus() const{ return m_status; }
+    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
+    inline void SetStatus(const ExistingObjectReplicationStatus& value) { m_statusHasBeenSet = true; m_status = value; }
+    inline void SetStatus(ExistingObjectReplicationStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
+    inline ExistingObjectReplication& WithStatus(const ExistingObjectReplicationStatus& value) { SetStatus(value); return *this;}
+    inline ExistingObjectReplication& WithStatus(ExistingObjectReplicationStatus&& value) { SetStatus(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    ExistingObjectReplicationStatus m_status;
+    bool m_statusHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace S3
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/s3/model/ExistingObjectReplicationStatus.h

@@ -0,0 +1,31 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/s3/S3_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace S3
+{
+namespace Model
+{
+  enum class ExistingObjectReplicationStatus
+  {
+    NOT_SET,
+    Enabled,
+    Disabled
+  };
+
+namespace ExistingObjectReplicationStatusMapper
+{
+AWS_S3_API ExistingObjectReplicationStatus GetExistingObjectReplicationStatusForName(const Aws::String& name);
+
+AWS_S3_API Aws::String GetNameForExistingObjectReplicationStatus(ExistingObjectReplicationStatus value);
+} // namespace ExistingObjectReplicationStatusMapper
+} // namespace Model
+} // namespace S3
+} // namespace Aws