GameLiftClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/gamelift/GameLiftPaginationBase.h>
#include <aws/gamelift/GameLiftServiceClientModel.h>
#include <aws/gamelift/GameLiftWaiter.h>
#include <aws/gamelift/GameLift_EXPORTS.h>
 
namespace Aws {
namespace GameLift {
class AWS_GAMELIFT_API GameLiftClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<GameLiftClient>,
                                        public GameLiftPaginationBase<GameLiftClient>,
                                        public GameLiftWaiter<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::CreateContainerFleetOutcome CreateContainerFleet(const Model::CreateContainerFleetRequest& request) const;
 
  template <typename CreateContainerFleetRequestT = Model::CreateContainerFleetRequest>
  Model::CreateContainerFleetOutcomeCallable CreateContainerFleetCallable(const CreateContainerFleetRequestT& request) const {
    return SubmitCallable(&GameLiftClient::CreateContainerFleet, request);
  }
 
  template <typename CreateContainerFleetRequestT = Model::CreateContainerFleetRequest>
  void CreateContainerFleetAsync(const CreateContainerFleetRequestT& request, const CreateContainerFleetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::CreateContainerFleet, 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::DeleteContainerFleetOutcome DeleteContainerFleet(const Model::DeleteContainerFleetRequest& request) const;
 
  template <typename DeleteContainerFleetRequestT = Model::DeleteContainerFleetRequest>
  Model::DeleteContainerFleetOutcomeCallable DeleteContainerFleetCallable(const DeleteContainerFleetRequestT& request) const {
    return SubmitCallable(&GameLiftClient::DeleteContainerFleet, request);
  }
 
  template <typename DeleteContainerFleetRequestT = Model::DeleteContainerFleetRequest>
  void DeleteContainerFleetAsync(const DeleteContainerFleetRequestT& request, const DeleteContainerFleetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::DeleteContainerFleet, 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::DescribeContainerFleetOutcome DescribeContainerFleet(const Model::DescribeContainerFleetRequest& request) const;
 
  template <typename DescribeContainerFleetRequestT = Model::DescribeContainerFleetRequest>
  Model::DescribeContainerFleetOutcomeCallable DescribeContainerFleetCallable(const DescribeContainerFleetRequestT& request) const {
    return SubmitCallable(&GameLiftClient::DescribeContainerFleet, request);
  }
 
  template <typename DescribeContainerFleetRequestT = Model::DescribeContainerFleetRequest>
  void DescribeContainerFleetAsync(const DescribeContainerFleetRequestT& request,
                                   const DescribeContainerFleetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::DescribeContainerFleet, 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::DescribeFleetDeploymentOutcome DescribeFleetDeployment(const Model::DescribeFleetDeploymentRequest& request) const;
 
  template <typename DescribeFleetDeploymentRequestT = Model::DescribeFleetDeploymentRequest>
  Model::DescribeFleetDeploymentOutcomeCallable DescribeFleetDeploymentCallable(const DescribeFleetDeploymentRequestT& request) const {
    return SubmitCallable(&GameLiftClient::DescribeFleetDeployment, request);
  }
 
  template <typename DescribeFleetDeploymentRequestT = Model::DescribeFleetDeploymentRequest>
  void DescribeFleetDeploymentAsync(const DescribeFleetDeploymentRequestT& request,
                                    const DescribeFleetDeploymentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::DescribeFleetDeployment, 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::GetPlayerConnectionDetailsOutcome GetPlayerConnectionDetails(
      const Model::GetPlayerConnectionDetailsRequest& request) const;
 
  template <typename GetPlayerConnectionDetailsRequestT = Model::GetPlayerConnectionDetailsRequest>
  Model::GetPlayerConnectionDetailsOutcomeCallable GetPlayerConnectionDetailsCallable(
      const GetPlayerConnectionDetailsRequestT& request) const {
    return SubmitCallable(&GameLiftClient::GetPlayerConnectionDetails, request);
  }
 
  template <typename GetPlayerConnectionDetailsRequestT = Model::GetPlayerConnectionDetailsRequest>
  void GetPlayerConnectionDetailsAsync(const GetPlayerConnectionDetailsRequestT& request,
                                       const GetPlayerConnectionDetailsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::GetPlayerConnectionDetails, 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::ListContainerFleetsOutcome ListContainerFleets(const Model::ListContainerFleetsRequest& request = {}) const;
 
  template <typename ListContainerFleetsRequestT = Model::ListContainerFleetsRequest>
  Model::ListContainerFleetsOutcomeCallable ListContainerFleetsCallable(const ListContainerFleetsRequestT& request = {}) const {
    return SubmitCallable(&GameLiftClient::ListContainerFleets, request);
  }
 
  template <typename ListContainerFleetsRequestT = Model::ListContainerFleetsRequest>
  void ListContainerFleetsAsync(const ListContainerFleetsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListContainerFleetsRequestT& request = {}) const {
    return SubmitAsync(&GameLiftClient::ListContainerFleets, request, handler, context);
  }
 
  virtual Model::ListContainerGroupDefinitionVersionsOutcome ListContainerGroupDefinitionVersions(
      const Model::ListContainerGroupDefinitionVersionsRequest& request) const;
 
  template <typename ListContainerGroupDefinitionVersionsRequestT = Model::ListContainerGroupDefinitionVersionsRequest>
  Model::ListContainerGroupDefinitionVersionsOutcomeCallable ListContainerGroupDefinitionVersionsCallable(
      const ListContainerGroupDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GameLiftClient::ListContainerGroupDefinitionVersions, request);
  }
 
  template <typename ListContainerGroupDefinitionVersionsRequestT = Model::ListContainerGroupDefinitionVersionsRequest>
  void ListContainerGroupDefinitionVersionsAsync(const ListContainerGroupDefinitionVersionsRequestT& request,
                                                 const ListContainerGroupDefinitionVersionsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::ListContainerGroupDefinitionVersions, 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::ListFleetDeploymentsOutcome ListFleetDeployments(const Model::ListFleetDeploymentsRequest& request = {}) const;
 
  template <typename ListFleetDeploymentsRequestT = Model::ListFleetDeploymentsRequest>
  Model::ListFleetDeploymentsOutcomeCallable ListFleetDeploymentsCallable(const ListFleetDeploymentsRequestT& request = {}) const {
    return SubmitCallable(&GameLiftClient::ListFleetDeployments, request);
  }
 
  template <typename ListFleetDeploymentsRequestT = Model::ListFleetDeploymentsRequest>
  void ListFleetDeploymentsAsync(const ListFleetDeploymentsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListFleetDeploymentsRequestT& request = {}) const {
    return SubmitAsync(&GameLiftClient::ListFleetDeployments, 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::TerminateGameSessionOutcome TerminateGameSession(const Model::TerminateGameSessionRequest& request) const;
 
  template <typename TerminateGameSessionRequestT = Model::TerminateGameSessionRequest>
  Model::TerminateGameSessionOutcomeCallable TerminateGameSessionCallable(const TerminateGameSessionRequestT& request) const {
    return SubmitCallable(&GameLiftClient::TerminateGameSession, request);
  }
 
  template <typename TerminateGameSessionRequestT = Model::TerminateGameSessionRequest>
  void TerminateGameSessionAsync(const TerminateGameSessionRequestT& request, const TerminateGameSessionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::TerminateGameSession, 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::UpdateContainerFleetOutcome UpdateContainerFleet(const Model::UpdateContainerFleetRequest& request) const;
 
  template <typename UpdateContainerFleetRequestT = Model::UpdateContainerFleetRequest>
  Model::UpdateContainerFleetOutcomeCallable UpdateContainerFleetCallable(const UpdateContainerFleetRequestT& request) const {
    return SubmitCallable(&GameLiftClient::UpdateContainerFleet, request);
  }
 
  template <typename UpdateContainerFleetRequestT = Model::UpdateContainerFleetRequest>
  void UpdateContainerFleetAsync(const UpdateContainerFleetRequestT& request, const UpdateContainerFleetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::UpdateContainerFleet, request, handler, context);
  }
 
  virtual Model::UpdateContainerGroupDefinitionOutcome UpdateContainerGroupDefinition(
      const Model::UpdateContainerGroupDefinitionRequest& request) const;
 
  template <typename UpdateContainerGroupDefinitionRequestT = Model::UpdateContainerGroupDefinitionRequest>
  Model::UpdateContainerGroupDefinitionOutcomeCallable UpdateContainerGroupDefinitionCallable(
      const UpdateContainerGroupDefinitionRequestT& request) const {
    return SubmitCallable(&GameLiftClient::UpdateContainerGroupDefinition, request);
  }
 
  template <typename UpdateContainerGroupDefinitionRequestT = Model::UpdateContainerGroupDefinitionRequest>
  void UpdateContainerGroupDefinitionAsync(const UpdateContainerGroupDefinitionRequestT& request,
                                           const UpdateContainerGroupDefinitionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftClient::UpdateContainerGroupDefinition, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GameLiftEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GameLiftClient>;
  void init(const GameLiftClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GameLiftError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  GameLiftClientConfiguration m_clientConfiguration;
  std::shared_ptr<GameLiftEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GameLift
}  // namespace Aws