GameLiftClient.h

 
#pragma once
#include <aws/gamelift/GameLift_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/gamelift/GameLiftServiceClientModel.h>
 
namespace Aws
{
namespace GameLift
{
  class AWS_GAMELIFT_API GameLiftClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<GameLiftClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef GameLiftClientConfiguration ClientConfigurationType;
      typedef GameLiftEndpointProvider EndpointProviderType;
 
        GameLiftClient(const Aws::GameLift::GameLiftClientConfiguration& clientConfiguration = Aws::GameLift::GameLiftClientConfiguration(),
                       std::shared_ptr<GameLiftEndpointProviderBase> endpointProvider = nullptr);
 
        GameLiftClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<GameLiftEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::GameLift::GameLiftClientConfiguration& clientConfiguration = Aws::GameLift::GameLiftClientConfiguration());
 
        GameLiftClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<GameLiftEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::GameLift::GameLiftClientConfiguration& clientConfiguration = Aws::GameLift::GameLiftClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        GameLiftClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GameLiftClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GameLiftClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~GameLiftClient();
 
        virtual Model::AcceptMatchOutcome AcceptMatch(const Model::AcceptMatchRequest& request) const;
 
        template<typename AcceptMatchRequestT = Model::AcceptMatchRequest>
        Model::AcceptMatchOutcomeCallable AcceptMatchCallable(const AcceptMatchRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::AcceptMatch, request);
        }
 
        template<typename AcceptMatchRequestT = Model::AcceptMatchRequest>
        void AcceptMatchAsync(const AcceptMatchRequestT& request, const AcceptMatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::AcceptMatch, request, handler, context);
        }
 
        virtual Model::ClaimGameServerOutcome ClaimGameServer(const Model::ClaimGameServerRequest& request) const;
 
        template<typename ClaimGameServerRequestT = Model::ClaimGameServerRequest>
        Model::ClaimGameServerOutcomeCallable ClaimGameServerCallable(const ClaimGameServerRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ClaimGameServer, request);
        }
 
        template<typename ClaimGameServerRequestT = Model::ClaimGameServerRequest>
        void ClaimGameServerAsync(const ClaimGameServerRequestT& request, const ClaimGameServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ClaimGameServer, request, handler, context);
        }
 
        virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const;
 
        template<typename CreateAliasRequestT = Model::CreateAliasRequest>
        Model::CreateAliasOutcomeCallable CreateAliasCallable(const CreateAliasRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateAlias, request);
        }
 
        template<typename CreateAliasRequestT = Model::CreateAliasRequest>
        void CreateAliasAsync(const CreateAliasRequestT& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateAlias, request, handler, context);
        }
 
        virtual Model::CreateBuildOutcome CreateBuild(const Model::CreateBuildRequest& request = {}) const;
 
        template<typename CreateBuildRequestT = Model::CreateBuildRequest>
        Model::CreateBuildOutcomeCallable CreateBuildCallable(const CreateBuildRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::CreateBuild, request);
        }
 
        template<typename CreateBuildRequestT = Model::CreateBuildRequest>
        void CreateBuildAsync(const CreateBuildResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateBuildRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::CreateBuild, request, handler, context);
        }
 
        virtual Model::CreateContainerGroupDefinitionOutcome CreateContainerGroupDefinition(const Model::CreateContainerGroupDefinitionRequest& request) const;
 
        template<typename CreateContainerGroupDefinitionRequestT = Model::CreateContainerGroupDefinitionRequest>
        Model::CreateContainerGroupDefinitionOutcomeCallable CreateContainerGroupDefinitionCallable(const CreateContainerGroupDefinitionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateContainerGroupDefinition, request);
        }
 
        template<typename CreateContainerGroupDefinitionRequestT = Model::CreateContainerGroupDefinitionRequest>
        void CreateContainerGroupDefinitionAsync(const CreateContainerGroupDefinitionRequestT& request, const CreateContainerGroupDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateContainerGroupDefinition, request, handler, context);
        }
 
        virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const;
 
        template<typename CreateFleetRequestT = Model::CreateFleetRequest>
        Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateFleet, request);
        }
 
        template<typename CreateFleetRequestT = Model::CreateFleetRequest>
        void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateFleet, request, handler, context);
        }
 
        virtual Model::CreateFleetLocationsOutcome CreateFleetLocations(const Model::CreateFleetLocationsRequest& request) const;
 
        template<typename CreateFleetLocationsRequestT = Model::CreateFleetLocationsRequest>
        Model::CreateFleetLocationsOutcomeCallable CreateFleetLocationsCallable(const CreateFleetLocationsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateFleetLocations, request);
        }
 
        template<typename CreateFleetLocationsRequestT = Model::CreateFleetLocationsRequest>
        void CreateFleetLocationsAsync(const CreateFleetLocationsRequestT& request, const CreateFleetLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateFleetLocations, request, handler, context);
        }
 
        virtual Model::CreateGameServerGroupOutcome CreateGameServerGroup(const Model::CreateGameServerGroupRequest& request) const;
 
        template<typename CreateGameServerGroupRequestT = Model::CreateGameServerGroupRequest>
        Model::CreateGameServerGroupOutcomeCallable CreateGameServerGroupCallable(const CreateGameServerGroupRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateGameServerGroup, request);
        }
 
        template<typename CreateGameServerGroupRequestT = Model::CreateGameServerGroupRequest>
        void CreateGameServerGroupAsync(const CreateGameServerGroupRequestT& request, const CreateGameServerGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateGameServerGroup, request, handler, context);
        }
 
        virtual Model::CreateGameSessionOutcome CreateGameSession(const Model::CreateGameSessionRequest& request) const;
 
        template<typename CreateGameSessionRequestT = Model::CreateGameSessionRequest>
        Model::CreateGameSessionOutcomeCallable CreateGameSessionCallable(const CreateGameSessionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateGameSession, request);
        }
 
        template<typename CreateGameSessionRequestT = Model::CreateGameSessionRequest>
        void CreateGameSessionAsync(const CreateGameSessionRequestT& request, const CreateGameSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateGameSession, request, handler, context);
        }
 
        virtual Model::CreateGameSessionQueueOutcome CreateGameSessionQueue(const Model::CreateGameSessionQueueRequest& request) const;
 
        template<typename CreateGameSessionQueueRequestT = Model::CreateGameSessionQueueRequest>
        Model::CreateGameSessionQueueOutcomeCallable CreateGameSessionQueueCallable(const CreateGameSessionQueueRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateGameSessionQueue, request);
        }
 
        template<typename CreateGameSessionQueueRequestT = Model::CreateGameSessionQueueRequest>
        void CreateGameSessionQueueAsync(const CreateGameSessionQueueRequestT& request, const CreateGameSessionQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateGameSessionQueue, request, handler, context);
        }
 
        virtual Model::CreateLocationOutcome CreateLocation(const Model::CreateLocationRequest& request) const;
 
        template<typename CreateLocationRequestT = Model::CreateLocationRequest>
        Model::CreateLocationOutcomeCallable CreateLocationCallable(const CreateLocationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateLocation, request);
        }
 
        template<typename CreateLocationRequestT = Model::CreateLocationRequest>
        void CreateLocationAsync(const CreateLocationRequestT& request, const CreateLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateLocation, request, handler, context);
        }
 
        virtual Model::CreateMatchmakingConfigurationOutcome CreateMatchmakingConfiguration(const Model::CreateMatchmakingConfigurationRequest& request) const;
 
        template<typename CreateMatchmakingConfigurationRequestT = Model::CreateMatchmakingConfigurationRequest>
        Model::CreateMatchmakingConfigurationOutcomeCallable CreateMatchmakingConfigurationCallable(const CreateMatchmakingConfigurationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateMatchmakingConfiguration, request);
        }
 
        template<typename CreateMatchmakingConfigurationRequestT = Model::CreateMatchmakingConfigurationRequest>
        void CreateMatchmakingConfigurationAsync(const CreateMatchmakingConfigurationRequestT& request, const CreateMatchmakingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateMatchmakingConfiguration, request, handler, context);
        }
 
        virtual Model::CreateMatchmakingRuleSetOutcome CreateMatchmakingRuleSet(const Model::CreateMatchmakingRuleSetRequest& request) const;
 
        template<typename CreateMatchmakingRuleSetRequestT = Model::CreateMatchmakingRuleSetRequest>
        Model::CreateMatchmakingRuleSetOutcomeCallable CreateMatchmakingRuleSetCallable(const CreateMatchmakingRuleSetRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateMatchmakingRuleSet, request);
        }
 
        template<typename CreateMatchmakingRuleSetRequestT = Model::CreateMatchmakingRuleSetRequest>
        void CreateMatchmakingRuleSetAsync(const CreateMatchmakingRuleSetRequestT& request, const CreateMatchmakingRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateMatchmakingRuleSet, request, handler, context);
        }
 
        virtual Model::CreatePlayerSessionOutcome CreatePlayerSession(const Model::CreatePlayerSessionRequest& request) const;
 
        template<typename CreatePlayerSessionRequestT = Model::CreatePlayerSessionRequest>
        Model::CreatePlayerSessionOutcomeCallable CreatePlayerSessionCallable(const CreatePlayerSessionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreatePlayerSession, request);
        }
 
        template<typename CreatePlayerSessionRequestT = Model::CreatePlayerSessionRequest>
        void CreatePlayerSessionAsync(const CreatePlayerSessionRequestT& request, const CreatePlayerSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreatePlayerSession, request, handler, context);
        }
 
        virtual Model::CreatePlayerSessionsOutcome CreatePlayerSessions(const Model::CreatePlayerSessionsRequest& request) const;
 
        template<typename CreatePlayerSessionsRequestT = Model::CreatePlayerSessionsRequest>
        Model::CreatePlayerSessionsOutcomeCallable CreatePlayerSessionsCallable(const CreatePlayerSessionsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreatePlayerSessions, request);
        }
 
        template<typename CreatePlayerSessionsRequestT = Model::CreatePlayerSessionsRequest>
        void CreatePlayerSessionsAsync(const CreatePlayerSessionsRequestT& request, const CreatePlayerSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreatePlayerSessions, request, handler, context);
        }
 
        virtual Model::CreateScriptOutcome CreateScript(const Model::CreateScriptRequest& request = {}) const;
 
        template<typename CreateScriptRequestT = Model::CreateScriptRequest>
        Model::CreateScriptOutcomeCallable CreateScriptCallable(const CreateScriptRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::CreateScript, request);
        }
 
        template<typename CreateScriptRequestT = Model::CreateScriptRequest>
        void CreateScriptAsync(const CreateScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateScriptRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::CreateScript, request, handler, context);
        }
 
        virtual Model::CreateVpcPeeringAuthorizationOutcome CreateVpcPeeringAuthorization(const Model::CreateVpcPeeringAuthorizationRequest& request) const;
 
        template<typename CreateVpcPeeringAuthorizationRequestT = Model::CreateVpcPeeringAuthorizationRequest>
        Model::CreateVpcPeeringAuthorizationOutcomeCallable CreateVpcPeeringAuthorizationCallable(const CreateVpcPeeringAuthorizationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateVpcPeeringAuthorization, request);
        }
 
        template<typename CreateVpcPeeringAuthorizationRequestT = Model::CreateVpcPeeringAuthorizationRequest>
        void CreateVpcPeeringAuthorizationAsync(const CreateVpcPeeringAuthorizationRequestT& request, const CreateVpcPeeringAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateVpcPeeringAuthorization, request, handler, context);
        }
 
        virtual Model::CreateVpcPeeringConnectionOutcome CreateVpcPeeringConnection(const Model::CreateVpcPeeringConnectionRequest& request) const;
 
        template<typename CreateVpcPeeringConnectionRequestT = Model::CreateVpcPeeringConnectionRequest>
        Model::CreateVpcPeeringConnectionOutcomeCallable CreateVpcPeeringConnectionCallable(const CreateVpcPeeringConnectionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::CreateVpcPeeringConnection, request);
        }
 
        template<typename CreateVpcPeeringConnectionRequestT = Model::CreateVpcPeeringConnectionRequest>
        void CreateVpcPeeringConnectionAsync(const CreateVpcPeeringConnectionRequestT& request, const CreateVpcPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::CreateVpcPeeringConnection, request, handler, context);
        }
 
        virtual Model::DeleteAliasOutcome DeleteAlias(const Model::DeleteAliasRequest& request) const;
 
        template<typename DeleteAliasRequestT = Model::DeleteAliasRequest>
        Model::DeleteAliasOutcomeCallable DeleteAliasCallable(const DeleteAliasRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteAlias, request);
        }
 
        template<typename DeleteAliasRequestT = Model::DeleteAliasRequest>
        void DeleteAliasAsync(const DeleteAliasRequestT& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteAlias, request, handler, context);
        }
 
        virtual Model::DeleteBuildOutcome DeleteBuild(const Model::DeleteBuildRequest& request) const;
 
        template<typename DeleteBuildRequestT = Model::DeleteBuildRequest>
        Model::DeleteBuildOutcomeCallable DeleteBuildCallable(const DeleteBuildRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteBuild, request);
        }
 
        template<typename DeleteBuildRequestT = Model::DeleteBuildRequest>
        void DeleteBuildAsync(const DeleteBuildRequestT& request, const DeleteBuildResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteBuild, request, handler, context);
        }
 
        virtual Model::DeleteContainerGroupDefinitionOutcome DeleteContainerGroupDefinition(const Model::DeleteContainerGroupDefinitionRequest& request) const;
 
        template<typename DeleteContainerGroupDefinitionRequestT = Model::DeleteContainerGroupDefinitionRequest>
        Model::DeleteContainerGroupDefinitionOutcomeCallable DeleteContainerGroupDefinitionCallable(const DeleteContainerGroupDefinitionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteContainerGroupDefinition, request);
        }
 
        template<typename DeleteContainerGroupDefinitionRequestT = Model::DeleteContainerGroupDefinitionRequest>
        void DeleteContainerGroupDefinitionAsync(const DeleteContainerGroupDefinitionRequestT& request, const DeleteContainerGroupDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteContainerGroupDefinition, request, handler, context);
        }
 
        virtual Model::DeleteFleetOutcome DeleteFleet(const Model::DeleteFleetRequest& request) const;
 
        template<typename DeleteFleetRequestT = Model::DeleteFleetRequest>
        Model::DeleteFleetOutcomeCallable DeleteFleetCallable(const DeleteFleetRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteFleet, request);
        }
 
        template<typename DeleteFleetRequestT = Model::DeleteFleetRequest>
        void DeleteFleetAsync(const DeleteFleetRequestT& request, const DeleteFleetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteFleet, request, handler, context);
        }
 
        virtual Model::DeleteFleetLocationsOutcome DeleteFleetLocations(const Model::DeleteFleetLocationsRequest& request) const;
 
        template<typename DeleteFleetLocationsRequestT = Model::DeleteFleetLocationsRequest>
        Model::DeleteFleetLocationsOutcomeCallable DeleteFleetLocationsCallable(const DeleteFleetLocationsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteFleetLocations, request);
        }
 
        template<typename DeleteFleetLocationsRequestT = Model::DeleteFleetLocationsRequest>
        void DeleteFleetLocationsAsync(const DeleteFleetLocationsRequestT& request, const DeleteFleetLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteFleetLocations, request, handler, context);
        }
 
        virtual Model::DeleteGameServerGroupOutcome DeleteGameServerGroup(const Model::DeleteGameServerGroupRequest& request) const;
 
        template<typename DeleteGameServerGroupRequestT = Model::DeleteGameServerGroupRequest>
        Model::DeleteGameServerGroupOutcomeCallable DeleteGameServerGroupCallable(const DeleteGameServerGroupRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteGameServerGroup, request);
        }
 
        template<typename DeleteGameServerGroupRequestT = Model::DeleteGameServerGroupRequest>
        void DeleteGameServerGroupAsync(const DeleteGameServerGroupRequestT& request, const DeleteGameServerGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteGameServerGroup, request, handler, context);
        }
 
        virtual Model::DeleteGameSessionQueueOutcome DeleteGameSessionQueue(const Model::DeleteGameSessionQueueRequest& request) const;
 
        template<typename DeleteGameSessionQueueRequestT = Model::DeleteGameSessionQueueRequest>
        Model::DeleteGameSessionQueueOutcomeCallable DeleteGameSessionQueueCallable(const DeleteGameSessionQueueRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteGameSessionQueue, request);
        }
 
        template<typename DeleteGameSessionQueueRequestT = Model::DeleteGameSessionQueueRequest>
        void DeleteGameSessionQueueAsync(const DeleteGameSessionQueueRequestT& request, const DeleteGameSessionQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteGameSessionQueue, request, handler, context);
        }
 
        virtual Model::DeleteLocationOutcome DeleteLocation(const Model::DeleteLocationRequest& request) const;
 
        template<typename DeleteLocationRequestT = Model::DeleteLocationRequest>
        Model::DeleteLocationOutcomeCallable DeleteLocationCallable(const DeleteLocationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteLocation, request);
        }
 
        template<typename DeleteLocationRequestT = Model::DeleteLocationRequest>
        void DeleteLocationAsync(const DeleteLocationRequestT& request, const DeleteLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteLocation, request, handler, context);
        }
 
        virtual Model::DeleteMatchmakingConfigurationOutcome DeleteMatchmakingConfiguration(const Model::DeleteMatchmakingConfigurationRequest& request) const;
 
        template<typename DeleteMatchmakingConfigurationRequestT = Model::DeleteMatchmakingConfigurationRequest>
        Model::DeleteMatchmakingConfigurationOutcomeCallable DeleteMatchmakingConfigurationCallable(const DeleteMatchmakingConfigurationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteMatchmakingConfiguration, request);
        }
 
        template<typename DeleteMatchmakingConfigurationRequestT = Model::DeleteMatchmakingConfigurationRequest>
        void DeleteMatchmakingConfigurationAsync(const DeleteMatchmakingConfigurationRequestT& request, const DeleteMatchmakingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteMatchmakingConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteMatchmakingRuleSetOutcome DeleteMatchmakingRuleSet(const Model::DeleteMatchmakingRuleSetRequest& request) const;
 
        template<typename DeleteMatchmakingRuleSetRequestT = Model::DeleteMatchmakingRuleSetRequest>
        Model::DeleteMatchmakingRuleSetOutcomeCallable DeleteMatchmakingRuleSetCallable(const DeleteMatchmakingRuleSetRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteMatchmakingRuleSet, request);
        }
 
        template<typename DeleteMatchmakingRuleSetRequestT = Model::DeleteMatchmakingRuleSetRequest>
        void DeleteMatchmakingRuleSetAsync(const DeleteMatchmakingRuleSetRequestT& request, const DeleteMatchmakingRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteMatchmakingRuleSet, request, handler, context);
        }
 
        virtual Model::DeleteScalingPolicyOutcome DeleteScalingPolicy(const Model::DeleteScalingPolicyRequest& request) const;
 
        template<typename DeleteScalingPolicyRequestT = Model::DeleteScalingPolicyRequest>
        Model::DeleteScalingPolicyOutcomeCallable DeleteScalingPolicyCallable(const DeleteScalingPolicyRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteScalingPolicy, request);
        }
 
        template<typename DeleteScalingPolicyRequestT = Model::DeleteScalingPolicyRequest>
        void DeleteScalingPolicyAsync(const DeleteScalingPolicyRequestT& request, const DeleteScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteScalingPolicy, request, handler, context);
        }
 
        virtual Model::DeleteScriptOutcome DeleteScript(const Model::DeleteScriptRequest& request) const;
 
        template<typename DeleteScriptRequestT = Model::DeleteScriptRequest>
        Model::DeleteScriptOutcomeCallable DeleteScriptCallable(const DeleteScriptRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteScript, request);
        }
 
        template<typename DeleteScriptRequestT = Model::DeleteScriptRequest>
        void DeleteScriptAsync(const DeleteScriptRequestT& request, const DeleteScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteScript, request, handler, context);
        }
 
        virtual Model::DeleteVpcPeeringAuthorizationOutcome DeleteVpcPeeringAuthorization(const Model::DeleteVpcPeeringAuthorizationRequest& request) const;
 
        template<typename DeleteVpcPeeringAuthorizationRequestT = Model::DeleteVpcPeeringAuthorizationRequest>
        Model::DeleteVpcPeeringAuthorizationOutcomeCallable DeleteVpcPeeringAuthorizationCallable(const DeleteVpcPeeringAuthorizationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteVpcPeeringAuthorization, request);
        }
 
        template<typename DeleteVpcPeeringAuthorizationRequestT = Model::DeleteVpcPeeringAuthorizationRequest>
        void DeleteVpcPeeringAuthorizationAsync(const DeleteVpcPeeringAuthorizationRequestT& request, const DeleteVpcPeeringAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteVpcPeeringAuthorization, request, handler, context);
        }
 
        virtual Model::DeleteVpcPeeringConnectionOutcome DeleteVpcPeeringConnection(const Model::DeleteVpcPeeringConnectionRequest& request) const;
 
        template<typename DeleteVpcPeeringConnectionRequestT = Model::DeleteVpcPeeringConnectionRequest>
        Model::DeleteVpcPeeringConnectionOutcomeCallable DeleteVpcPeeringConnectionCallable(const DeleteVpcPeeringConnectionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeleteVpcPeeringConnection, request);
        }
 
        template<typename DeleteVpcPeeringConnectionRequestT = Model::DeleteVpcPeeringConnectionRequest>
        void DeleteVpcPeeringConnectionAsync(const DeleteVpcPeeringConnectionRequestT& request, const DeleteVpcPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeleteVpcPeeringConnection, request, handler, context);
        }
 
        virtual Model::DeregisterComputeOutcome DeregisterCompute(const Model::DeregisterComputeRequest& request) const;
 
        template<typename DeregisterComputeRequestT = Model::DeregisterComputeRequest>
        Model::DeregisterComputeOutcomeCallable DeregisterComputeCallable(const DeregisterComputeRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeregisterCompute, request);
        }
 
        template<typename DeregisterComputeRequestT = Model::DeregisterComputeRequest>
        void DeregisterComputeAsync(const DeregisterComputeRequestT& request, const DeregisterComputeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeregisterCompute, request, handler, context);
        }
 
        virtual Model::DeregisterGameServerOutcome DeregisterGameServer(const Model::DeregisterGameServerRequest& request) const;
 
        template<typename DeregisterGameServerRequestT = Model::DeregisterGameServerRequest>
        Model::DeregisterGameServerOutcomeCallable DeregisterGameServerCallable(const DeregisterGameServerRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DeregisterGameServer, request);
        }
 
        template<typename DeregisterGameServerRequestT = Model::DeregisterGameServerRequest>
        void DeregisterGameServerAsync(const DeregisterGameServerRequestT& request, const DeregisterGameServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DeregisterGameServer, request, handler, context);
        }
 
        virtual Model::DescribeAliasOutcome DescribeAlias(const Model::DescribeAliasRequest& request) const;
 
        template<typename DescribeAliasRequestT = Model::DescribeAliasRequest>
        Model::DescribeAliasOutcomeCallable DescribeAliasCallable(const DescribeAliasRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeAlias, request);
        }
 
        template<typename DescribeAliasRequestT = Model::DescribeAliasRequest>
        void DescribeAliasAsync(const DescribeAliasRequestT& request, const DescribeAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeAlias, request, handler, context);
        }
 
        virtual Model::DescribeBuildOutcome DescribeBuild(const Model::DescribeBuildRequest& request) const;
 
        template<typename DescribeBuildRequestT = Model::DescribeBuildRequest>
        Model::DescribeBuildOutcomeCallable DescribeBuildCallable(const DescribeBuildRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeBuild, request);
        }
 
        template<typename DescribeBuildRequestT = Model::DescribeBuildRequest>
        void DescribeBuildAsync(const DescribeBuildRequestT& request, const DescribeBuildResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeBuild, request, handler, context);
        }
 
        virtual Model::DescribeComputeOutcome DescribeCompute(const Model::DescribeComputeRequest& request) const;
 
        template<typename DescribeComputeRequestT = Model::DescribeComputeRequest>
        Model::DescribeComputeOutcomeCallable DescribeComputeCallable(const DescribeComputeRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeCompute, request);
        }
 
        template<typename DescribeComputeRequestT = Model::DescribeComputeRequest>
        void DescribeComputeAsync(const DescribeComputeRequestT& request, const DescribeComputeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeCompute, request, handler, context);
        }
 
        virtual Model::DescribeContainerGroupDefinitionOutcome DescribeContainerGroupDefinition(const Model::DescribeContainerGroupDefinitionRequest& request) const;
 
        template<typename DescribeContainerGroupDefinitionRequestT = Model::DescribeContainerGroupDefinitionRequest>
        Model::DescribeContainerGroupDefinitionOutcomeCallable DescribeContainerGroupDefinitionCallable(const DescribeContainerGroupDefinitionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeContainerGroupDefinition, request);
        }
 
        template<typename DescribeContainerGroupDefinitionRequestT = Model::DescribeContainerGroupDefinitionRequest>
        void DescribeContainerGroupDefinitionAsync(const DescribeContainerGroupDefinitionRequestT& request, const DescribeContainerGroupDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeContainerGroupDefinition, request, handler, context);
        }
 
        virtual Model::DescribeEC2InstanceLimitsOutcome DescribeEC2InstanceLimits(const Model::DescribeEC2InstanceLimitsRequest& request = {}) const;
 
        template<typename DescribeEC2InstanceLimitsRequestT = Model::DescribeEC2InstanceLimitsRequest>
        Model::DescribeEC2InstanceLimitsOutcomeCallable DescribeEC2InstanceLimitsCallable(const DescribeEC2InstanceLimitsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeEC2InstanceLimits, request);
        }
 
        template<typename DescribeEC2InstanceLimitsRequestT = Model::DescribeEC2InstanceLimitsRequest>
        void DescribeEC2InstanceLimitsAsync(const DescribeEC2InstanceLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEC2InstanceLimitsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeEC2InstanceLimits, request, handler, context);
        }
 
        virtual Model::DescribeFleetAttributesOutcome DescribeFleetAttributes(const Model::DescribeFleetAttributesRequest& request = {}) const;
 
        template<typename DescribeFleetAttributesRequestT = Model::DescribeFleetAttributesRequest>
        Model::DescribeFleetAttributesOutcomeCallable DescribeFleetAttributesCallable(const DescribeFleetAttributesRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetAttributes, request);
        }
 
        template<typename DescribeFleetAttributesRequestT = Model::DescribeFleetAttributesRequest>
        void DescribeFleetAttributesAsync(const DescribeFleetAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetAttributesRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetAttributes, request, handler, context);
        }
 
        virtual Model::DescribeFleetCapacityOutcome DescribeFleetCapacity(const Model::DescribeFleetCapacityRequest& request = {}) const;
 
        template<typename DescribeFleetCapacityRequestT = Model::DescribeFleetCapacityRequest>
        Model::DescribeFleetCapacityOutcomeCallable DescribeFleetCapacityCallable(const DescribeFleetCapacityRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetCapacity, request);
        }
 
        template<typename DescribeFleetCapacityRequestT = Model::DescribeFleetCapacityRequest>
        void DescribeFleetCapacityAsync(const DescribeFleetCapacityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetCapacityRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetCapacity, request, handler, context);
        }
 
        virtual Model::DescribeFleetEventsOutcome DescribeFleetEvents(const Model::DescribeFleetEventsRequest& request) const;
 
        template<typename DescribeFleetEventsRequestT = Model::DescribeFleetEventsRequest>
        Model::DescribeFleetEventsOutcomeCallable DescribeFleetEventsCallable(const DescribeFleetEventsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetEvents, request);
        }
 
        template<typename DescribeFleetEventsRequestT = Model::DescribeFleetEventsRequest>
        void DescribeFleetEventsAsync(const DescribeFleetEventsRequestT& request, const DescribeFleetEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetEvents, request, handler, context);
        }
 
        virtual Model::DescribeFleetLocationAttributesOutcome DescribeFleetLocationAttributes(const Model::DescribeFleetLocationAttributesRequest& request) const;
 
        template<typename DescribeFleetLocationAttributesRequestT = Model::DescribeFleetLocationAttributesRequest>
        Model::DescribeFleetLocationAttributesOutcomeCallable DescribeFleetLocationAttributesCallable(const DescribeFleetLocationAttributesRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetLocationAttributes, request);
        }
 
        template<typename DescribeFleetLocationAttributesRequestT = Model::DescribeFleetLocationAttributesRequest>
        void DescribeFleetLocationAttributesAsync(const DescribeFleetLocationAttributesRequestT& request, const DescribeFleetLocationAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetLocationAttributes, request, handler, context);
        }
 
        virtual Model::DescribeFleetLocationCapacityOutcome DescribeFleetLocationCapacity(const Model::DescribeFleetLocationCapacityRequest& request) const;
 
        template<typename DescribeFleetLocationCapacityRequestT = Model::DescribeFleetLocationCapacityRequest>
        Model::DescribeFleetLocationCapacityOutcomeCallable DescribeFleetLocationCapacityCallable(const DescribeFleetLocationCapacityRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetLocationCapacity, request);
        }
 
        template<typename DescribeFleetLocationCapacityRequestT = Model::DescribeFleetLocationCapacityRequest>
        void DescribeFleetLocationCapacityAsync(const DescribeFleetLocationCapacityRequestT& request, const DescribeFleetLocationCapacityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetLocationCapacity, request, handler, context);
        }
 
        virtual Model::DescribeFleetLocationUtilizationOutcome DescribeFleetLocationUtilization(const Model::DescribeFleetLocationUtilizationRequest& request) const;
 
        template<typename DescribeFleetLocationUtilizationRequestT = Model::DescribeFleetLocationUtilizationRequest>
        Model::DescribeFleetLocationUtilizationOutcomeCallable DescribeFleetLocationUtilizationCallable(const DescribeFleetLocationUtilizationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetLocationUtilization, request);
        }
 
        template<typename DescribeFleetLocationUtilizationRequestT = Model::DescribeFleetLocationUtilizationRequest>
        void DescribeFleetLocationUtilizationAsync(const DescribeFleetLocationUtilizationRequestT& request, const DescribeFleetLocationUtilizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetLocationUtilization, request, handler, context);
        }
 
        virtual Model::DescribeFleetPortSettingsOutcome DescribeFleetPortSettings(const Model::DescribeFleetPortSettingsRequest& request) const;
 
        template<typename DescribeFleetPortSettingsRequestT = Model::DescribeFleetPortSettingsRequest>
        Model::DescribeFleetPortSettingsOutcomeCallable DescribeFleetPortSettingsCallable(const DescribeFleetPortSettingsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetPortSettings, request);
        }
 
        template<typename DescribeFleetPortSettingsRequestT = Model::DescribeFleetPortSettingsRequest>
        void DescribeFleetPortSettingsAsync(const DescribeFleetPortSettingsRequestT& request, const DescribeFleetPortSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetPortSettings, request, handler, context);
        }
 
        virtual Model::DescribeFleetUtilizationOutcome DescribeFleetUtilization(const Model::DescribeFleetUtilizationRequest& request = {}) const;
 
        template<typename DescribeFleetUtilizationRequestT = Model::DescribeFleetUtilizationRequest>
        Model::DescribeFleetUtilizationOutcomeCallable DescribeFleetUtilizationCallable(const DescribeFleetUtilizationRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeFleetUtilization, request);
        }
 
        template<typename DescribeFleetUtilizationRequestT = Model::DescribeFleetUtilizationRequest>
        void DescribeFleetUtilizationAsync(const DescribeFleetUtilizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFleetUtilizationRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeFleetUtilization, request, handler, context);
        }
 
        virtual Model::DescribeGameServerOutcome DescribeGameServer(const Model::DescribeGameServerRequest& request) const;
 
        template<typename DescribeGameServerRequestT = Model::DescribeGameServerRequest>
        Model::DescribeGameServerOutcomeCallable DescribeGameServerCallable(const DescribeGameServerRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameServer, request);
        }
 
        template<typename DescribeGameServerRequestT = Model::DescribeGameServerRequest>
        void DescribeGameServerAsync(const DescribeGameServerRequestT& request, const DescribeGameServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameServer, request, handler, context);
        }
 
        virtual Model::DescribeGameServerGroupOutcome DescribeGameServerGroup(const Model::DescribeGameServerGroupRequest& request) const;
 
        template<typename DescribeGameServerGroupRequestT = Model::DescribeGameServerGroupRequest>
        Model::DescribeGameServerGroupOutcomeCallable DescribeGameServerGroupCallable(const DescribeGameServerGroupRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameServerGroup, request);
        }
 
        template<typename DescribeGameServerGroupRequestT = Model::DescribeGameServerGroupRequest>
        void DescribeGameServerGroupAsync(const DescribeGameServerGroupRequestT& request, const DescribeGameServerGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameServerGroup, request, handler, context);
        }
 
        virtual Model::DescribeGameServerInstancesOutcome DescribeGameServerInstances(const Model::DescribeGameServerInstancesRequest& request) const;
 
        template<typename DescribeGameServerInstancesRequestT = Model::DescribeGameServerInstancesRequest>
        Model::DescribeGameServerInstancesOutcomeCallable DescribeGameServerInstancesCallable(const DescribeGameServerInstancesRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameServerInstances, request);
        }
 
        template<typename DescribeGameServerInstancesRequestT = Model::DescribeGameServerInstancesRequest>
        void DescribeGameServerInstancesAsync(const DescribeGameServerInstancesRequestT& request, const DescribeGameServerInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameServerInstances, request, handler, context);
        }
 
        virtual Model::DescribeGameSessionDetailsOutcome DescribeGameSessionDetails(const Model::DescribeGameSessionDetailsRequest& request = {}) const;
 
        template<typename DescribeGameSessionDetailsRequestT = Model::DescribeGameSessionDetailsRequest>
        Model::DescribeGameSessionDetailsOutcomeCallable DescribeGameSessionDetailsCallable(const DescribeGameSessionDetailsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameSessionDetails, request);
        }
 
        template<typename DescribeGameSessionDetailsRequestT = Model::DescribeGameSessionDetailsRequest>
        void DescribeGameSessionDetailsAsync(const DescribeGameSessionDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeGameSessionDetailsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameSessionDetails, request, handler, context);
        }
 
        virtual Model::DescribeGameSessionPlacementOutcome DescribeGameSessionPlacement(const Model::DescribeGameSessionPlacementRequest& request) const;
 
        template<typename DescribeGameSessionPlacementRequestT = Model::DescribeGameSessionPlacementRequest>
        Model::DescribeGameSessionPlacementOutcomeCallable DescribeGameSessionPlacementCallable(const DescribeGameSessionPlacementRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameSessionPlacement, request);
        }
 
        template<typename DescribeGameSessionPlacementRequestT = Model::DescribeGameSessionPlacementRequest>
        void DescribeGameSessionPlacementAsync(const DescribeGameSessionPlacementRequestT& request, const DescribeGameSessionPlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameSessionPlacement, request, handler, context);
        }
 
        virtual Model::DescribeGameSessionQueuesOutcome DescribeGameSessionQueues(const Model::DescribeGameSessionQueuesRequest& request = {}) const;
 
        template<typename DescribeGameSessionQueuesRequestT = Model::DescribeGameSessionQueuesRequest>
        Model::DescribeGameSessionQueuesOutcomeCallable DescribeGameSessionQueuesCallable(const DescribeGameSessionQueuesRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameSessionQueues, request);
        }
 
        template<typename DescribeGameSessionQueuesRequestT = Model::DescribeGameSessionQueuesRequest>
        void DescribeGameSessionQueuesAsync(const DescribeGameSessionQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeGameSessionQueuesRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameSessionQueues, request, handler, context);
        }
 
        virtual Model::DescribeGameSessionsOutcome DescribeGameSessions(const Model::DescribeGameSessionsRequest& request = {}) const;
 
        template<typename DescribeGameSessionsRequestT = Model::DescribeGameSessionsRequest>
        Model::DescribeGameSessionsOutcomeCallable DescribeGameSessionsCallable(const DescribeGameSessionsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeGameSessions, request);
        }
 
        template<typename DescribeGameSessionsRequestT = Model::DescribeGameSessionsRequest>
        void DescribeGameSessionsAsync(const DescribeGameSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeGameSessionsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeGameSessions, request, handler, context);
        }
 
        virtual Model::DescribeInstancesOutcome DescribeInstances(const Model::DescribeInstancesRequest& request) const;
 
        template<typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
        Model::DescribeInstancesOutcomeCallable DescribeInstancesCallable(const DescribeInstancesRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeInstances, request);
        }
 
        template<typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
        void DescribeInstancesAsync(const DescribeInstancesRequestT& request, const DescribeInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeInstances, request, handler, context);
        }
 
        virtual Model::DescribeMatchmakingOutcome DescribeMatchmaking(const Model::DescribeMatchmakingRequest& request) const;
 
        template<typename DescribeMatchmakingRequestT = Model::DescribeMatchmakingRequest>
        Model::DescribeMatchmakingOutcomeCallable DescribeMatchmakingCallable(const DescribeMatchmakingRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeMatchmaking, request);
        }
 
        template<typename DescribeMatchmakingRequestT = Model::DescribeMatchmakingRequest>
        void DescribeMatchmakingAsync(const DescribeMatchmakingRequestT& request, const DescribeMatchmakingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeMatchmaking, request, handler, context);
        }
 
        virtual Model::DescribeMatchmakingConfigurationsOutcome DescribeMatchmakingConfigurations(const Model::DescribeMatchmakingConfigurationsRequest& request = {}) const;
 
        template<typename DescribeMatchmakingConfigurationsRequestT = Model::DescribeMatchmakingConfigurationsRequest>
        Model::DescribeMatchmakingConfigurationsOutcomeCallable DescribeMatchmakingConfigurationsCallable(const DescribeMatchmakingConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeMatchmakingConfigurations, request);
        }
 
        template<typename DescribeMatchmakingConfigurationsRequestT = Model::DescribeMatchmakingConfigurationsRequest>
        void DescribeMatchmakingConfigurationsAsync(const DescribeMatchmakingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMatchmakingConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeMatchmakingConfigurations, request, handler, context);
        }
 
        virtual Model::DescribeMatchmakingRuleSetsOutcome DescribeMatchmakingRuleSets(const Model::DescribeMatchmakingRuleSetsRequest& request = {}) const;
 
        template<typename DescribeMatchmakingRuleSetsRequestT = Model::DescribeMatchmakingRuleSetsRequest>
        Model::DescribeMatchmakingRuleSetsOutcomeCallable DescribeMatchmakingRuleSetsCallable(const DescribeMatchmakingRuleSetsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeMatchmakingRuleSets, request);
        }
 
        template<typename DescribeMatchmakingRuleSetsRequestT = Model::DescribeMatchmakingRuleSetsRequest>
        void DescribeMatchmakingRuleSetsAsync(const DescribeMatchmakingRuleSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeMatchmakingRuleSetsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeMatchmakingRuleSets, request, handler, context);
        }
 
        virtual Model::DescribePlayerSessionsOutcome DescribePlayerSessions(const Model::DescribePlayerSessionsRequest& request = {}) const;
 
        template<typename DescribePlayerSessionsRequestT = Model::DescribePlayerSessionsRequest>
        Model::DescribePlayerSessionsOutcomeCallable DescribePlayerSessionsCallable(const DescribePlayerSessionsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribePlayerSessions, request);
        }
 
        template<typename DescribePlayerSessionsRequestT = Model::DescribePlayerSessionsRequest>
        void DescribePlayerSessionsAsync(const DescribePlayerSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribePlayerSessionsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribePlayerSessions, request, handler, context);
        }
 
        virtual Model::DescribeRuntimeConfigurationOutcome DescribeRuntimeConfiguration(const Model::DescribeRuntimeConfigurationRequest& request) const;
 
        template<typename DescribeRuntimeConfigurationRequestT = Model::DescribeRuntimeConfigurationRequest>
        Model::DescribeRuntimeConfigurationOutcomeCallable DescribeRuntimeConfigurationCallable(const DescribeRuntimeConfigurationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeRuntimeConfiguration, request);
        }
 
        template<typename DescribeRuntimeConfigurationRequestT = Model::DescribeRuntimeConfigurationRequest>
        void DescribeRuntimeConfigurationAsync(const DescribeRuntimeConfigurationRequestT& request, const DescribeRuntimeConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeRuntimeConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeScalingPoliciesOutcome DescribeScalingPolicies(const Model::DescribeScalingPoliciesRequest& request) const;
 
        template<typename DescribeScalingPoliciesRequestT = Model::DescribeScalingPoliciesRequest>
        Model::DescribeScalingPoliciesOutcomeCallable DescribeScalingPoliciesCallable(const DescribeScalingPoliciesRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeScalingPolicies, request);
        }
 
        template<typename DescribeScalingPoliciesRequestT = Model::DescribeScalingPoliciesRequest>
        void DescribeScalingPoliciesAsync(const DescribeScalingPoliciesRequestT& request, const DescribeScalingPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeScalingPolicies, request, handler, context);
        }
 
        virtual Model::DescribeScriptOutcome DescribeScript(const Model::DescribeScriptRequest& request) const;
 
        template<typename DescribeScriptRequestT = Model::DescribeScriptRequest>
        Model::DescribeScriptOutcomeCallable DescribeScriptCallable(const DescribeScriptRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::DescribeScript, request);
        }
 
        template<typename DescribeScriptRequestT = Model::DescribeScriptRequest>
        void DescribeScriptAsync(const DescribeScriptRequestT& request, const DescribeScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::DescribeScript, request, handler, context);
        }
 
        virtual Model::DescribeVpcPeeringAuthorizationsOutcome DescribeVpcPeeringAuthorizations(const Model::DescribeVpcPeeringAuthorizationsRequest& request = {}) const;
 
        template<typename DescribeVpcPeeringAuthorizationsRequestT = Model::DescribeVpcPeeringAuthorizationsRequest>
        Model::DescribeVpcPeeringAuthorizationsOutcomeCallable DescribeVpcPeeringAuthorizationsCallable(const DescribeVpcPeeringAuthorizationsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeVpcPeeringAuthorizations, request);
        }
 
        template<typename DescribeVpcPeeringAuthorizationsRequestT = Model::DescribeVpcPeeringAuthorizationsRequest>
        void DescribeVpcPeeringAuthorizationsAsync(const DescribeVpcPeeringAuthorizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeVpcPeeringAuthorizationsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeVpcPeeringAuthorizations, request, handler, context);
        }
 
        virtual Model::DescribeVpcPeeringConnectionsOutcome DescribeVpcPeeringConnections(const Model::DescribeVpcPeeringConnectionsRequest& request = {}) const;
 
        template<typename DescribeVpcPeeringConnectionsRequestT = Model::DescribeVpcPeeringConnectionsRequest>
        Model::DescribeVpcPeeringConnectionsOutcomeCallable DescribeVpcPeeringConnectionsCallable(const DescribeVpcPeeringConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::DescribeVpcPeeringConnections, request);
        }
 
        template<typename DescribeVpcPeeringConnectionsRequestT = Model::DescribeVpcPeeringConnectionsRequest>
        void DescribeVpcPeeringConnectionsAsync(const DescribeVpcPeeringConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeVpcPeeringConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::DescribeVpcPeeringConnections, request, handler, context);
        }
 
        virtual Model::GetComputeAccessOutcome GetComputeAccess(const Model::GetComputeAccessRequest& request) const;
 
        template<typename GetComputeAccessRequestT = Model::GetComputeAccessRequest>
        Model::GetComputeAccessOutcomeCallable GetComputeAccessCallable(const GetComputeAccessRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::GetComputeAccess, request);
        }
 
        template<typename GetComputeAccessRequestT = Model::GetComputeAccessRequest>
        void GetComputeAccessAsync(const GetComputeAccessRequestT& request, const GetComputeAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::GetComputeAccess, request, handler, context);
        }
 
        virtual Model::GetComputeAuthTokenOutcome GetComputeAuthToken(const Model::GetComputeAuthTokenRequest& request) const;
 
        template<typename GetComputeAuthTokenRequestT = Model::GetComputeAuthTokenRequest>
        Model::GetComputeAuthTokenOutcomeCallable GetComputeAuthTokenCallable(const GetComputeAuthTokenRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::GetComputeAuthToken, request);
        }
 
        template<typename GetComputeAuthTokenRequestT = Model::GetComputeAuthTokenRequest>
        void GetComputeAuthTokenAsync(const GetComputeAuthTokenRequestT& request, const GetComputeAuthTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::GetComputeAuthToken, request, handler, context);
        }
 
        virtual Model::GetGameSessionLogUrlOutcome GetGameSessionLogUrl(const Model::GetGameSessionLogUrlRequest& request) const;
 
        template<typename GetGameSessionLogUrlRequestT = Model::GetGameSessionLogUrlRequest>
        Model::GetGameSessionLogUrlOutcomeCallable GetGameSessionLogUrlCallable(const GetGameSessionLogUrlRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::GetGameSessionLogUrl, request);
        }
 
        template<typename GetGameSessionLogUrlRequestT = Model::GetGameSessionLogUrlRequest>
        void GetGameSessionLogUrlAsync(const GetGameSessionLogUrlRequestT& request, const GetGameSessionLogUrlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::GetGameSessionLogUrl, request, handler, context);
        }
 
        virtual Model::GetInstanceAccessOutcome GetInstanceAccess(const Model::GetInstanceAccessRequest& request) const;
 
        template<typename GetInstanceAccessRequestT = Model::GetInstanceAccessRequest>
        Model::GetInstanceAccessOutcomeCallable GetInstanceAccessCallable(const GetInstanceAccessRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::GetInstanceAccess, request);
        }
 
        template<typename GetInstanceAccessRequestT = Model::GetInstanceAccessRequest>
        void GetInstanceAccessAsync(const GetInstanceAccessRequestT& request, const GetInstanceAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::GetInstanceAccess, request, handler, context);
        }
 
        virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request = {}) const;
 
        template<typename ListAliasesRequestT = Model::ListAliasesRequest>
        Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListAliases, request);
        }
 
        template<typename ListAliasesRequestT = Model::ListAliasesRequest>
        void ListAliasesAsync(const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAliasesRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListAliases, request, handler, context);
        }
 
        virtual Model::ListBuildsOutcome ListBuilds(const Model::ListBuildsRequest& request = {}) const;
 
        template<typename ListBuildsRequestT = Model::ListBuildsRequest>
        Model::ListBuildsOutcomeCallable ListBuildsCallable(const ListBuildsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListBuilds, request);
        }
 
        template<typename ListBuildsRequestT = Model::ListBuildsRequest>
        void ListBuildsAsync(const ListBuildsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBuildsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListBuilds, request, handler, context);
        }
 
        virtual Model::ListComputeOutcome ListCompute(const Model::ListComputeRequest& request) const;
 
        template<typename ListComputeRequestT = Model::ListComputeRequest>
        Model::ListComputeOutcomeCallable ListComputeCallable(const ListComputeRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ListCompute, request);
        }
 
        template<typename ListComputeRequestT = Model::ListComputeRequest>
        void ListComputeAsync(const ListComputeRequestT& request, const ListComputeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ListCompute, request, handler, context);
        }
 
        virtual Model::ListContainerGroupDefinitionsOutcome ListContainerGroupDefinitions(const Model::ListContainerGroupDefinitionsRequest& request = {}) const;
 
        template<typename ListContainerGroupDefinitionsRequestT = Model::ListContainerGroupDefinitionsRequest>
        Model::ListContainerGroupDefinitionsOutcomeCallable ListContainerGroupDefinitionsCallable(const ListContainerGroupDefinitionsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListContainerGroupDefinitions, request);
        }
 
        template<typename ListContainerGroupDefinitionsRequestT = Model::ListContainerGroupDefinitionsRequest>
        void ListContainerGroupDefinitionsAsync(const ListContainerGroupDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListContainerGroupDefinitionsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListContainerGroupDefinitions, request, handler, context);
        }
 
        virtual Model::ListFleetsOutcome ListFleets(const Model::ListFleetsRequest& request = {}) const;
 
        template<typename ListFleetsRequestT = Model::ListFleetsRequest>
        Model::ListFleetsOutcomeCallable ListFleetsCallable(const ListFleetsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListFleets, request);
        }
 
        template<typename ListFleetsRequestT = Model::ListFleetsRequest>
        void ListFleetsAsync(const ListFleetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFleetsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListFleets, request, handler, context);
        }
 
        virtual Model::ListGameServerGroupsOutcome ListGameServerGroups(const Model::ListGameServerGroupsRequest& request = {}) const;
 
        template<typename ListGameServerGroupsRequestT = Model::ListGameServerGroupsRequest>
        Model::ListGameServerGroupsOutcomeCallable ListGameServerGroupsCallable(const ListGameServerGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListGameServerGroups, request);
        }
 
        template<typename ListGameServerGroupsRequestT = Model::ListGameServerGroupsRequest>
        void ListGameServerGroupsAsync(const ListGameServerGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGameServerGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListGameServerGroups, request, handler, context);
        }
 
        virtual Model::ListGameServersOutcome ListGameServers(const Model::ListGameServersRequest& request) const;
 
        template<typename ListGameServersRequestT = Model::ListGameServersRequest>
        Model::ListGameServersOutcomeCallable ListGameServersCallable(const ListGameServersRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ListGameServers, request);
        }
 
        template<typename ListGameServersRequestT = Model::ListGameServersRequest>
        void ListGameServersAsync(const ListGameServersRequestT& request, const ListGameServersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ListGameServers, request, handler, context);
        }
 
        virtual Model::ListLocationsOutcome ListLocations(const Model::ListLocationsRequest& request = {}) const;
 
        template<typename ListLocationsRequestT = Model::ListLocationsRequest>
        Model::ListLocationsOutcomeCallable ListLocationsCallable(const ListLocationsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListLocations, request);
        }
 
        template<typename ListLocationsRequestT = Model::ListLocationsRequest>
        void ListLocationsAsync(const ListLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLocationsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListLocations, request, handler, context);
        }
 
        virtual Model::ListScriptsOutcome ListScripts(const Model::ListScriptsRequest& request = {}) const;
 
        template<typename ListScriptsRequestT = Model::ListScriptsRequest>
        Model::ListScriptsOutcomeCallable ListScriptsCallable(const ListScriptsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::ListScripts, request);
        }
 
        template<typename ListScriptsRequestT = Model::ListScriptsRequest>
        void ListScriptsAsync(const ListScriptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListScriptsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::ListScripts, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutScalingPolicyOutcome PutScalingPolicy(const Model::PutScalingPolicyRequest& request) const;
 
        template<typename PutScalingPolicyRequestT = Model::PutScalingPolicyRequest>
        Model::PutScalingPolicyOutcomeCallable PutScalingPolicyCallable(const PutScalingPolicyRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::PutScalingPolicy, request);
        }
 
        template<typename PutScalingPolicyRequestT = Model::PutScalingPolicyRequest>
        void PutScalingPolicyAsync(const PutScalingPolicyRequestT& request, const PutScalingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::PutScalingPolicy, request, handler, context);
        }
 
        virtual Model::RegisterComputeOutcome RegisterCompute(const Model::RegisterComputeRequest& request) const;
 
        template<typename RegisterComputeRequestT = Model::RegisterComputeRequest>
        Model::RegisterComputeOutcomeCallable RegisterComputeCallable(const RegisterComputeRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::RegisterCompute, request);
        }
 
        template<typename RegisterComputeRequestT = Model::RegisterComputeRequest>
        void RegisterComputeAsync(const RegisterComputeRequestT& request, const RegisterComputeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::RegisterCompute, request, handler, context);
        }
 
        virtual Model::RegisterGameServerOutcome RegisterGameServer(const Model::RegisterGameServerRequest& request) const;
 
        template<typename RegisterGameServerRequestT = Model::RegisterGameServerRequest>
        Model::RegisterGameServerOutcomeCallable RegisterGameServerCallable(const RegisterGameServerRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::RegisterGameServer, request);
        }
 
        template<typename RegisterGameServerRequestT = Model::RegisterGameServerRequest>
        void RegisterGameServerAsync(const RegisterGameServerRequestT& request, const RegisterGameServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::RegisterGameServer, request, handler, context);
        }
 
        virtual Model::RequestUploadCredentialsOutcome RequestUploadCredentials(const Model::RequestUploadCredentialsRequest& request) const;
 
        template<typename RequestUploadCredentialsRequestT = Model::RequestUploadCredentialsRequest>
        Model::RequestUploadCredentialsOutcomeCallable RequestUploadCredentialsCallable(const RequestUploadCredentialsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::RequestUploadCredentials, request);
        }
 
        template<typename RequestUploadCredentialsRequestT = Model::RequestUploadCredentialsRequest>
        void RequestUploadCredentialsAsync(const RequestUploadCredentialsRequestT& request, const RequestUploadCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::RequestUploadCredentials, request, handler, context);
        }
 
        virtual Model::ResolveAliasOutcome ResolveAlias(const Model::ResolveAliasRequest& request) const;
 
        template<typename ResolveAliasRequestT = Model::ResolveAliasRequest>
        Model::ResolveAliasOutcomeCallable ResolveAliasCallable(const ResolveAliasRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ResolveAlias, request);
        }
 
        template<typename ResolveAliasRequestT = Model::ResolveAliasRequest>
        void ResolveAliasAsync(const ResolveAliasRequestT& request, const ResolveAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ResolveAlias, request, handler, context);
        }
 
        virtual Model::ResumeGameServerGroupOutcome ResumeGameServerGroup(const Model::ResumeGameServerGroupRequest& request) const;
 
        template<typename ResumeGameServerGroupRequestT = Model::ResumeGameServerGroupRequest>
        Model::ResumeGameServerGroupOutcomeCallable ResumeGameServerGroupCallable(const ResumeGameServerGroupRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ResumeGameServerGroup, request);
        }
 
        template<typename ResumeGameServerGroupRequestT = Model::ResumeGameServerGroupRequest>
        void ResumeGameServerGroupAsync(const ResumeGameServerGroupRequestT& request, const ResumeGameServerGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ResumeGameServerGroup, request, handler, context);
        }
 
        virtual Model::SearchGameSessionsOutcome SearchGameSessions(const Model::SearchGameSessionsRequest& request = {}) const;
 
        template<typename SearchGameSessionsRequestT = Model::SearchGameSessionsRequest>
        Model::SearchGameSessionsOutcomeCallable SearchGameSessionsCallable(const SearchGameSessionsRequestT& request = {}) const
        {
            return SubmitCallable(&GameLiftClient::SearchGameSessions, request);
        }
 
        template<typename SearchGameSessionsRequestT = Model::SearchGameSessionsRequest>
        void SearchGameSessionsAsync(const SearchGameSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchGameSessionsRequestT& request = {}) const
        {
            return SubmitAsync(&GameLiftClient::SearchGameSessions, request, handler, context);
        }
 
        virtual Model::StartFleetActionsOutcome StartFleetActions(const Model::StartFleetActionsRequest& request) const;
 
        template<typename StartFleetActionsRequestT = Model::StartFleetActionsRequest>
        Model::StartFleetActionsOutcomeCallable StartFleetActionsCallable(const StartFleetActionsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StartFleetActions, request);
        }
 
        template<typename StartFleetActionsRequestT = Model::StartFleetActionsRequest>
        void StartFleetActionsAsync(const StartFleetActionsRequestT& request, const StartFleetActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StartFleetActions, request, handler, context);
        }
 
        virtual Model::StartGameSessionPlacementOutcome StartGameSessionPlacement(const Model::StartGameSessionPlacementRequest& request) const;
 
        template<typename StartGameSessionPlacementRequestT = Model::StartGameSessionPlacementRequest>
        Model::StartGameSessionPlacementOutcomeCallable StartGameSessionPlacementCallable(const StartGameSessionPlacementRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StartGameSessionPlacement, request);
        }
 
        template<typename StartGameSessionPlacementRequestT = Model::StartGameSessionPlacementRequest>
        void StartGameSessionPlacementAsync(const StartGameSessionPlacementRequestT& request, const StartGameSessionPlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StartGameSessionPlacement, request, handler, context);
        }
 
        virtual Model::StartMatchBackfillOutcome StartMatchBackfill(const Model::StartMatchBackfillRequest& request) const;
 
        template<typename StartMatchBackfillRequestT = Model::StartMatchBackfillRequest>
        Model::StartMatchBackfillOutcomeCallable StartMatchBackfillCallable(const StartMatchBackfillRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StartMatchBackfill, request);
        }
 
        template<typename StartMatchBackfillRequestT = Model::StartMatchBackfillRequest>
        void StartMatchBackfillAsync(const StartMatchBackfillRequestT& request, const StartMatchBackfillResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StartMatchBackfill, request, handler, context);
        }
 
        virtual Model::StartMatchmakingOutcome StartMatchmaking(const Model::StartMatchmakingRequest& request) const;
 
        template<typename StartMatchmakingRequestT = Model::StartMatchmakingRequest>
        Model::StartMatchmakingOutcomeCallable StartMatchmakingCallable(const StartMatchmakingRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StartMatchmaking, request);
        }
 
        template<typename StartMatchmakingRequestT = Model::StartMatchmakingRequest>
        void StartMatchmakingAsync(const StartMatchmakingRequestT& request, const StartMatchmakingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StartMatchmaking, request, handler, context);
        }
 
        virtual Model::StopFleetActionsOutcome StopFleetActions(const Model::StopFleetActionsRequest& request) const;
 
        template<typename StopFleetActionsRequestT = Model::StopFleetActionsRequest>
        Model::StopFleetActionsOutcomeCallable StopFleetActionsCallable(const StopFleetActionsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StopFleetActions, request);
        }
 
        template<typename StopFleetActionsRequestT = Model::StopFleetActionsRequest>
        void StopFleetActionsAsync(const StopFleetActionsRequestT& request, const StopFleetActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StopFleetActions, request, handler, context);
        }
 
        virtual Model::StopGameSessionPlacementOutcome StopGameSessionPlacement(const Model::StopGameSessionPlacementRequest& request) const;
 
        template<typename StopGameSessionPlacementRequestT = Model::StopGameSessionPlacementRequest>
        Model::StopGameSessionPlacementOutcomeCallable StopGameSessionPlacementCallable(const StopGameSessionPlacementRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StopGameSessionPlacement, request);
        }
 
        template<typename StopGameSessionPlacementRequestT = Model::StopGameSessionPlacementRequest>
        void StopGameSessionPlacementAsync(const StopGameSessionPlacementRequestT& request, const StopGameSessionPlacementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StopGameSessionPlacement, request, handler, context);
        }
 
        virtual Model::StopMatchmakingOutcome StopMatchmaking(const Model::StopMatchmakingRequest& request) const;
 
        template<typename StopMatchmakingRequestT = Model::StopMatchmakingRequest>
        Model::StopMatchmakingOutcomeCallable StopMatchmakingCallable(const StopMatchmakingRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::StopMatchmaking, request);
        }
 
        template<typename StopMatchmakingRequestT = Model::StopMatchmakingRequest>
        void StopMatchmakingAsync(const StopMatchmakingRequestT& request, const StopMatchmakingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::StopMatchmaking, request, handler, context);
        }
 
        virtual Model::SuspendGameServerGroupOutcome SuspendGameServerGroup(const Model::SuspendGameServerGroupRequest& request) const;
 
        template<typename SuspendGameServerGroupRequestT = Model::SuspendGameServerGroupRequest>
        Model::SuspendGameServerGroupOutcomeCallable SuspendGameServerGroupCallable(const SuspendGameServerGroupRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::SuspendGameServerGroup, request);
        }
 
        template<typename SuspendGameServerGroupRequestT = Model::SuspendGameServerGroupRequest>
        void SuspendGameServerGroupAsync(const SuspendGameServerGroupRequestT& request, const SuspendGameServerGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::SuspendGameServerGroup, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAliasOutcome UpdateAlias(const Model::UpdateAliasRequest& request) const;
 
        template<typename UpdateAliasRequestT = Model::UpdateAliasRequest>
        Model::UpdateAliasOutcomeCallable UpdateAliasCallable(const UpdateAliasRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateAlias, request);
        }
 
        template<typename UpdateAliasRequestT = Model::UpdateAliasRequest>
        void UpdateAliasAsync(const UpdateAliasRequestT& request, const UpdateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateAlias, request, handler, context);
        }
 
        virtual Model::UpdateBuildOutcome UpdateBuild(const Model::UpdateBuildRequest& request) const;
 
        template<typename UpdateBuildRequestT = Model::UpdateBuildRequest>
        Model::UpdateBuildOutcomeCallable UpdateBuildCallable(const UpdateBuildRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateBuild, request);
        }
 
        template<typename UpdateBuildRequestT = Model::UpdateBuildRequest>
        void UpdateBuildAsync(const UpdateBuildRequestT& request, const UpdateBuildResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateBuild, request, handler, context);
        }
 
        virtual Model::UpdateFleetAttributesOutcome UpdateFleetAttributes(const Model::UpdateFleetAttributesRequest& request) const;
 
        template<typename UpdateFleetAttributesRequestT = Model::UpdateFleetAttributesRequest>
        Model::UpdateFleetAttributesOutcomeCallable UpdateFleetAttributesCallable(const UpdateFleetAttributesRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateFleetAttributes, request);
        }
 
        template<typename UpdateFleetAttributesRequestT = Model::UpdateFleetAttributesRequest>
        void UpdateFleetAttributesAsync(const UpdateFleetAttributesRequestT& request, const UpdateFleetAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateFleetAttributes, request, handler, context);
        }
 
        virtual Model::UpdateFleetCapacityOutcome UpdateFleetCapacity(const Model::UpdateFleetCapacityRequest& request) const;
 
        template<typename UpdateFleetCapacityRequestT = Model::UpdateFleetCapacityRequest>
        Model::UpdateFleetCapacityOutcomeCallable UpdateFleetCapacityCallable(const UpdateFleetCapacityRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateFleetCapacity, request);
        }
 
        template<typename UpdateFleetCapacityRequestT = Model::UpdateFleetCapacityRequest>
        void UpdateFleetCapacityAsync(const UpdateFleetCapacityRequestT& request, const UpdateFleetCapacityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateFleetCapacity, request, handler, context);
        }
 
        virtual Model::UpdateFleetPortSettingsOutcome UpdateFleetPortSettings(const Model::UpdateFleetPortSettingsRequest& request) const;
 
        template<typename UpdateFleetPortSettingsRequestT = Model::UpdateFleetPortSettingsRequest>
        Model::UpdateFleetPortSettingsOutcomeCallable UpdateFleetPortSettingsCallable(const UpdateFleetPortSettingsRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateFleetPortSettings, request);
        }
 
        template<typename UpdateFleetPortSettingsRequestT = Model::UpdateFleetPortSettingsRequest>
        void UpdateFleetPortSettingsAsync(const UpdateFleetPortSettingsRequestT& request, const UpdateFleetPortSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateFleetPortSettings, request, handler, context);
        }
 
        virtual Model::UpdateGameServerOutcome UpdateGameServer(const Model::UpdateGameServerRequest& request) const;
 
        template<typename UpdateGameServerRequestT = Model::UpdateGameServerRequest>
        Model::UpdateGameServerOutcomeCallable UpdateGameServerCallable(const UpdateGameServerRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateGameServer, request);
        }
 
        template<typename UpdateGameServerRequestT = Model::UpdateGameServerRequest>
        void UpdateGameServerAsync(const UpdateGameServerRequestT& request, const UpdateGameServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateGameServer, request, handler, context);
        }
 
        virtual Model::UpdateGameServerGroupOutcome UpdateGameServerGroup(const Model::UpdateGameServerGroupRequest& request) const;
 
        template<typename UpdateGameServerGroupRequestT = Model::UpdateGameServerGroupRequest>
        Model::UpdateGameServerGroupOutcomeCallable UpdateGameServerGroupCallable(const UpdateGameServerGroupRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateGameServerGroup, request);
        }
 
        template<typename UpdateGameServerGroupRequestT = Model::UpdateGameServerGroupRequest>
        void UpdateGameServerGroupAsync(const UpdateGameServerGroupRequestT& request, const UpdateGameServerGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateGameServerGroup, request, handler, context);
        }
 
        virtual Model::UpdateGameSessionOutcome UpdateGameSession(const Model::UpdateGameSessionRequest& request) const;
 
        template<typename UpdateGameSessionRequestT = Model::UpdateGameSessionRequest>
        Model::UpdateGameSessionOutcomeCallable UpdateGameSessionCallable(const UpdateGameSessionRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateGameSession, request);
        }
 
        template<typename UpdateGameSessionRequestT = Model::UpdateGameSessionRequest>
        void UpdateGameSessionAsync(const UpdateGameSessionRequestT& request, const UpdateGameSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateGameSession, request, handler, context);
        }
 
        virtual Model::UpdateGameSessionQueueOutcome UpdateGameSessionQueue(const Model::UpdateGameSessionQueueRequest& request) const;
 
        template<typename UpdateGameSessionQueueRequestT = Model::UpdateGameSessionQueueRequest>
        Model::UpdateGameSessionQueueOutcomeCallable UpdateGameSessionQueueCallable(const UpdateGameSessionQueueRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateGameSessionQueue, request);
        }
 
        template<typename UpdateGameSessionQueueRequestT = Model::UpdateGameSessionQueueRequest>
        void UpdateGameSessionQueueAsync(const UpdateGameSessionQueueRequestT& request, const UpdateGameSessionQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateGameSessionQueue, request, handler, context);
        }
 
        virtual Model::UpdateMatchmakingConfigurationOutcome UpdateMatchmakingConfiguration(const Model::UpdateMatchmakingConfigurationRequest& request) const;
 
        template<typename UpdateMatchmakingConfigurationRequestT = Model::UpdateMatchmakingConfigurationRequest>
        Model::UpdateMatchmakingConfigurationOutcomeCallable UpdateMatchmakingConfigurationCallable(const UpdateMatchmakingConfigurationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateMatchmakingConfiguration, request);
        }
 
        template<typename UpdateMatchmakingConfigurationRequestT = Model::UpdateMatchmakingConfigurationRequest>
        void UpdateMatchmakingConfigurationAsync(const UpdateMatchmakingConfigurationRequestT& request, const UpdateMatchmakingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateMatchmakingConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateRuntimeConfigurationOutcome UpdateRuntimeConfiguration(const Model::UpdateRuntimeConfigurationRequest& request) const;
 
        template<typename UpdateRuntimeConfigurationRequestT = Model::UpdateRuntimeConfigurationRequest>
        Model::UpdateRuntimeConfigurationOutcomeCallable UpdateRuntimeConfigurationCallable(const UpdateRuntimeConfigurationRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateRuntimeConfiguration, request);
        }
 
        template<typename UpdateRuntimeConfigurationRequestT = Model::UpdateRuntimeConfigurationRequest>
        void UpdateRuntimeConfigurationAsync(const UpdateRuntimeConfigurationRequestT& request, const UpdateRuntimeConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateRuntimeConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateScriptOutcome UpdateScript(const Model::UpdateScriptRequest& request) const;
 
        template<typename UpdateScriptRequestT = Model::UpdateScriptRequest>
        Model::UpdateScriptOutcomeCallable UpdateScriptCallable(const UpdateScriptRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::UpdateScript, request);
        }
 
        template<typename UpdateScriptRequestT = Model::UpdateScriptRequest>
        void UpdateScriptAsync(const UpdateScriptRequestT& request, const UpdateScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::UpdateScript, request, handler, context);
        }
 
        virtual Model::ValidateMatchmakingRuleSetOutcome ValidateMatchmakingRuleSet(const Model::ValidateMatchmakingRuleSetRequest& request) const;
 
        template<typename ValidateMatchmakingRuleSetRequestT = Model::ValidateMatchmakingRuleSetRequest>
        Model::ValidateMatchmakingRuleSetOutcomeCallable ValidateMatchmakingRuleSetCallable(const ValidateMatchmakingRuleSetRequestT& request) const
        {
            return SubmitCallable(&GameLiftClient::ValidateMatchmakingRuleSet, request);
        }
 
        template<typename ValidateMatchmakingRuleSetRequestT = Model::ValidateMatchmakingRuleSetRequest>
        void ValidateMatchmakingRuleSetAsync(const ValidateMatchmakingRuleSetRequestT& request, const ValidateMatchmakingRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GameLiftClient::ValidateMatchmakingRuleSet, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GameLiftEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GameLiftClient>;
      void init(const GameLiftClientConfiguration& clientConfiguration);
 
      GameLiftClientConfiguration m_clientConfiguration;
      std::shared_ptr<GameLiftEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace GameLift
} // namespace Aws