GameLiftStreamsClient.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/gameliftstreams/GameLiftStreamsPaginationBase.h>
#include <aws/gameliftstreams/GameLiftStreamsServiceClientModel.h>
#include <aws/gameliftstreams/GameLiftStreamsWaiter.h>
#include <aws/gameliftstreams/GameLiftStreams_EXPORTS.h>
 
namespace Aws {
namespace GameLiftStreams {
class AWS_GAMELIFTSTREAMS_API GameLiftStreamsClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<GameLiftStreamsClient>,
                                                      public GameLiftStreamsPaginationBase<GameLiftStreamsClient>,
                                                      public GameLiftStreamsWaiter<GameLiftStreamsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GameLiftStreamsClientConfiguration ClientConfigurationType;
  typedef GameLiftStreamsEndpointProvider EndpointProviderType;
 
  GameLiftStreamsClient(const Aws::GameLiftStreams::GameLiftStreamsClientConfiguration& clientConfiguration =
                            Aws::GameLiftStreams::GameLiftStreamsClientConfiguration(),
                        std::shared_ptr<GameLiftStreamsEndpointProviderBase> endpointProvider = nullptr);
 
  GameLiftStreamsClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<GameLiftStreamsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::GameLiftStreams::GameLiftStreamsClientConfiguration& clientConfiguration =
                            Aws::GameLiftStreams::GameLiftStreamsClientConfiguration());
 
  GameLiftStreamsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<GameLiftStreamsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::GameLiftStreams::GameLiftStreamsClientConfiguration& clientConfiguration =
                            Aws::GameLiftStreams::GameLiftStreamsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GameLiftStreamsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GameLiftStreamsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GameLiftStreamsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GameLiftStreamsClient();
 
  virtual Model::AddStreamGroupLocationsOutcome AddStreamGroupLocations(const Model::AddStreamGroupLocationsRequest& request) const;
 
  template <typename AddStreamGroupLocationsRequestT = Model::AddStreamGroupLocationsRequest>
  Model::AddStreamGroupLocationsOutcomeCallable AddStreamGroupLocationsCallable(const AddStreamGroupLocationsRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::AddStreamGroupLocations, request);
  }
 
  template <typename AddStreamGroupLocationsRequestT = Model::AddStreamGroupLocationsRequest>
  void AddStreamGroupLocationsAsync(const AddStreamGroupLocationsRequestT& request,
                                    const AddStreamGroupLocationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::AddStreamGroupLocations, request, handler, context);
  }
 
  virtual Model::AssociateApplicationsOutcome AssociateApplications(const Model::AssociateApplicationsRequest& request) const;
 
  template <typename AssociateApplicationsRequestT = Model::AssociateApplicationsRequest>
  Model::AssociateApplicationsOutcomeCallable AssociateApplicationsCallable(const AssociateApplicationsRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::AssociateApplications, request);
  }
 
  template <typename AssociateApplicationsRequestT = Model::AssociateApplicationsRequest>
  void AssociateApplicationsAsync(const AssociateApplicationsRequestT& request, const AssociateApplicationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::AssociateApplications, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateStreamGroupOutcome CreateStreamGroup(const Model::CreateStreamGroupRequest& request) const;
 
  template <typename CreateStreamGroupRequestT = Model::CreateStreamGroupRequest>
  Model::CreateStreamGroupOutcomeCallable CreateStreamGroupCallable(const CreateStreamGroupRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::CreateStreamGroup, request);
  }
 
  template <typename CreateStreamGroupRequestT = Model::CreateStreamGroupRequest>
  void CreateStreamGroupAsync(const CreateStreamGroupRequestT& request, const CreateStreamGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::CreateStreamGroup, request, handler, context);
  }
 
  virtual Model::CreateStreamSessionAdminShellOutcome CreateStreamSessionAdminShell(
      const Model::CreateStreamSessionAdminShellRequest& request) const;
 
  template <typename CreateStreamSessionAdminShellRequestT = Model::CreateStreamSessionAdminShellRequest>
  Model::CreateStreamSessionAdminShellOutcomeCallable CreateStreamSessionAdminShellCallable(
      const CreateStreamSessionAdminShellRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::CreateStreamSessionAdminShell, request);
  }
 
  template <typename CreateStreamSessionAdminShellRequestT = Model::CreateStreamSessionAdminShellRequest>
  void CreateStreamSessionAdminShellAsync(const CreateStreamSessionAdminShellRequestT& request,
                                          const CreateStreamSessionAdminShellResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::CreateStreamSessionAdminShell, request, handler, context);
  }
 
  virtual Model::CreateStreamSessionConnectionOutcome CreateStreamSessionConnection(
      const Model::CreateStreamSessionConnectionRequest& request) const;
 
  template <typename CreateStreamSessionConnectionRequestT = Model::CreateStreamSessionConnectionRequest>
  Model::CreateStreamSessionConnectionOutcomeCallable CreateStreamSessionConnectionCallable(
      const CreateStreamSessionConnectionRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::CreateStreamSessionConnection, request);
  }
 
  template <typename CreateStreamSessionConnectionRequestT = Model::CreateStreamSessionConnectionRequest>
  void CreateStreamSessionConnectionAsync(const CreateStreamSessionConnectionRequestT& request,
                                          const CreateStreamSessionConnectionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::CreateStreamSessionConnection, request, handler, context);
  }
 
  virtual Model::CreateStreamUrlOutcome CreateStreamUrl(const Model::CreateStreamUrlRequest& request) const;
 
  template <typename CreateStreamUrlRequestT = Model::CreateStreamUrlRequest>
  Model::CreateStreamUrlOutcomeCallable CreateStreamUrlCallable(const CreateStreamUrlRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::CreateStreamUrl, request);
  }
 
  template <typename CreateStreamUrlRequestT = Model::CreateStreamUrlRequest>
  void CreateStreamUrlAsync(const CreateStreamUrlRequestT& request, const CreateStreamUrlResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::CreateStreamUrl, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteStreamGroupOutcome DeleteStreamGroup(const Model::DeleteStreamGroupRequest& request) const;
 
  template <typename DeleteStreamGroupRequestT = Model::DeleteStreamGroupRequest>
  Model::DeleteStreamGroupOutcomeCallable DeleteStreamGroupCallable(const DeleteStreamGroupRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::DeleteStreamGroup, request);
  }
 
  template <typename DeleteStreamGroupRequestT = Model::DeleteStreamGroupRequest>
  void DeleteStreamGroupAsync(const DeleteStreamGroupRequestT& request, const DeleteStreamGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::DeleteStreamGroup, request, handler, context);
  }
 
  virtual Model::DisassociateApplicationsOutcome DisassociateApplications(const Model::DisassociateApplicationsRequest& request) const;
 
  template <typename DisassociateApplicationsRequestT = Model::DisassociateApplicationsRequest>
  Model::DisassociateApplicationsOutcomeCallable DisassociateApplicationsCallable(const DisassociateApplicationsRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::DisassociateApplications, request);
  }
 
  template <typename DisassociateApplicationsRequestT = Model::DisassociateApplicationsRequest>
  void DisassociateApplicationsAsync(const DisassociateApplicationsRequestT& request,
                                     const DisassociateApplicationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::DisassociateApplications, request, handler, context);
  }
 
  virtual Model::ExportStreamSessionFilesOutcome ExportStreamSessionFiles(const Model::ExportStreamSessionFilesRequest& request) const;
 
  template <typename ExportStreamSessionFilesRequestT = Model::ExportStreamSessionFilesRequest>
  Model::ExportStreamSessionFilesOutcomeCallable ExportStreamSessionFilesCallable(const ExportStreamSessionFilesRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::ExportStreamSessionFiles, request);
  }
 
  template <typename ExportStreamSessionFilesRequestT = Model::ExportStreamSessionFilesRequest>
  void ExportStreamSessionFilesAsync(const ExportStreamSessionFilesRequestT& request,
                                     const ExportStreamSessionFilesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::ExportStreamSessionFiles, request, handler, context);
  }
 
  virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::GetApplication, request);
  }
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::GetApplication, request, handler, context);
  }
 
  virtual Model::GetStreamGroupOutcome GetStreamGroup(const Model::GetStreamGroupRequest& request) const;
 
  template <typename GetStreamGroupRequestT = Model::GetStreamGroupRequest>
  Model::GetStreamGroupOutcomeCallable GetStreamGroupCallable(const GetStreamGroupRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::GetStreamGroup, request);
  }
 
  template <typename GetStreamGroupRequestT = Model::GetStreamGroupRequest>
  void GetStreamGroupAsync(const GetStreamGroupRequestT& request, const GetStreamGroupResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::GetStreamGroup, request, handler, context);
  }
 
  virtual Model::GetStreamSessionOutcome GetStreamSession(const Model::GetStreamSessionRequest& request) const;
 
  template <typename GetStreamSessionRequestT = Model::GetStreamSessionRequest>
  Model::GetStreamSessionOutcomeCallable GetStreamSessionCallable(const GetStreamSessionRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::GetStreamSession, request);
  }
 
  template <typename GetStreamSessionRequestT = Model::GetStreamSessionRequest>
  void GetStreamSessionAsync(const GetStreamSessionRequestT& request, const GetStreamSessionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::GetStreamSession, request, handler, context);
  }
 
  virtual Model::GetStreamUrlOutcome GetStreamUrl(const Model::GetStreamUrlRequest& request) const;
 
  template <typename GetStreamUrlRequestT = Model::GetStreamUrlRequest>
  Model::GetStreamUrlOutcomeCallable GetStreamUrlCallable(const GetStreamUrlRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::GetStreamUrl, request);
  }
 
  template <typename GetStreamUrlRequestT = Model::GetStreamUrlRequest>
  void GetStreamUrlAsync(const GetStreamUrlRequestT& request, const GetStreamUrlResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::GetStreamUrl, request, handler, context);
  }
 
  virtual Model::ListApplicationShaderCachesOutcome ListApplicationShaderCaches(
      const Model::ListApplicationShaderCachesRequest& request) const;
 
  template <typename ListApplicationShaderCachesRequestT = Model::ListApplicationShaderCachesRequest>
  Model::ListApplicationShaderCachesOutcomeCallable ListApplicationShaderCachesCallable(
      const ListApplicationShaderCachesRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::ListApplicationShaderCaches, request);
  }
 
  template <typename ListApplicationShaderCachesRequestT = Model::ListApplicationShaderCachesRequest>
  void ListApplicationShaderCachesAsync(const ListApplicationShaderCachesRequestT& request,
                                        const ListApplicationShaderCachesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::ListApplicationShaderCaches, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&GameLiftStreamsClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&GameLiftStreamsClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListStreamGroupsOutcome ListStreamGroups(const Model::ListStreamGroupsRequest& request = {}) const;
 
  template <typename ListStreamGroupsRequestT = Model::ListStreamGroupsRequest>
  Model::ListStreamGroupsOutcomeCallable ListStreamGroupsCallable(const ListStreamGroupsRequestT& request = {}) const {
    return SubmitCallable(&GameLiftStreamsClient::ListStreamGroups, request);
  }
 
  template <typename ListStreamGroupsRequestT = Model::ListStreamGroupsRequest>
  void ListStreamGroupsAsync(const ListStreamGroupsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListStreamGroupsRequestT& request = {}) const {
    return SubmitAsync(&GameLiftStreamsClient::ListStreamGroups, request, handler, context);
  }
 
  virtual Model::ListStreamSessionsOutcome ListStreamSessions(const Model::ListStreamSessionsRequest& request) const;
 
  template <typename ListStreamSessionsRequestT = Model::ListStreamSessionsRequest>
  Model::ListStreamSessionsOutcomeCallable ListStreamSessionsCallable(const ListStreamSessionsRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::ListStreamSessions, request);
  }
 
  template <typename ListStreamSessionsRequestT = Model::ListStreamSessionsRequest>
  void ListStreamSessionsAsync(const ListStreamSessionsRequestT& request, const ListStreamSessionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::ListStreamSessions, request, handler, context);
  }
 
  virtual Model::ListStreamSessionsByAccountOutcome ListStreamSessionsByAccount(
      const Model::ListStreamSessionsByAccountRequest& request = {}) const;
 
  template <typename ListStreamSessionsByAccountRequestT = Model::ListStreamSessionsByAccountRequest>
  Model::ListStreamSessionsByAccountOutcomeCallable ListStreamSessionsByAccountCallable(
      const ListStreamSessionsByAccountRequestT& request = {}) const {
    return SubmitCallable(&GameLiftStreamsClient::ListStreamSessionsByAccount, request);
  }
 
  template <typename ListStreamSessionsByAccountRequestT = Model::ListStreamSessionsByAccountRequest>
  void ListStreamSessionsByAccountAsync(const ListStreamSessionsByAccountResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListStreamSessionsByAccountRequestT& request = {}) const {
    return SubmitAsync(&GameLiftStreamsClient::ListStreamSessionsByAccount, request, handler, context);
  }
 
  virtual Model::ListStreamUrlsOutcome ListStreamUrls(const Model::ListStreamUrlsRequest& request = {}) const;
 
  template <typename ListStreamUrlsRequestT = Model::ListStreamUrlsRequest>
  Model::ListStreamUrlsOutcomeCallable ListStreamUrlsCallable(const ListStreamUrlsRequestT& request = {}) const {
    return SubmitCallable(&GameLiftStreamsClient::ListStreamUrls, request);
  }
 
  template <typename ListStreamUrlsRequestT = Model::ListStreamUrlsRequest>
  void ListStreamUrlsAsync(const ListStreamUrlsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListStreamUrlsRequestT& request = {}) const {
    return SubmitAsync(&GameLiftStreamsClient::ListStreamUrls, 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(&GameLiftStreamsClient::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(&GameLiftStreamsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RemoveStreamGroupLocationsOutcome RemoveStreamGroupLocations(
      const Model::RemoveStreamGroupLocationsRequest& request) const;
 
  template <typename RemoveStreamGroupLocationsRequestT = Model::RemoveStreamGroupLocationsRequest>
  Model::RemoveStreamGroupLocationsOutcomeCallable RemoveStreamGroupLocationsCallable(
      const RemoveStreamGroupLocationsRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::RemoveStreamGroupLocations, request);
  }
 
  template <typename RemoveStreamGroupLocationsRequestT = Model::RemoveStreamGroupLocationsRequest>
  void RemoveStreamGroupLocationsAsync(const RemoveStreamGroupLocationsRequestT& request,
                                       const RemoveStreamGroupLocationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::RemoveStreamGroupLocations, request, handler, context);
  }
 
  virtual Model::RevokeStreamUrlOutcome RevokeStreamUrl(const Model::RevokeStreamUrlRequest& request) const;
 
  template <typename RevokeStreamUrlRequestT = Model::RevokeStreamUrlRequest>
  Model::RevokeStreamUrlOutcomeCallable RevokeStreamUrlCallable(const RevokeStreamUrlRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::RevokeStreamUrl, request);
  }
 
  template <typename RevokeStreamUrlRequestT = Model::RevokeStreamUrlRequest>
  void RevokeStreamUrlAsync(const RevokeStreamUrlRequestT& request, const RevokeStreamUrlResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::RevokeStreamUrl, request, handler, context);
  }
 
  virtual Model::StartStreamSessionOutcome StartStreamSession(const Model::StartStreamSessionRequest& request) const;
 
  template <typename StartStreamSessionRequestT = Model::StartStreamSessionRequest>
  Model::StartStreamSessionOutcomeCallable StartStreamSessionCallable(const StartStreamSessionRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::StartStreamSession, request);
  }
 
  template <typename StartStreamSessionRequestT = Model::StartStreamSessionRequest>
  void StartStreamSessionAsync(const StartStreamSessionRequestT& request, const StartStreamSessionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::StartStreamSession, 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(&GameLiftStreamsClient::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(&GameLiftStreamsClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateStreamSessionOutcome TerminateStreamSession(const Model::TerminateStreamSessionRequest& request) const;
 
  template <typename TerminateStreamSessionRequestT = Model::TerminateStreamSessionRequest>
  Model::TerminateStreamSessionOutcomeCallable TerminateStreamSessionCallable(const TerminateStreamSessionRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::TerminateStreamSession, request);
  }
 
  template <typename TerminateStreamSessionRequestT = Model::TerminateStreamSessionRequest>
  void TerminateStreamSessionAsync(const TerminateStreamSessionRequestT& request,
                                   const TerminateStreamSessionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::TerminateStreamSession, 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(&GameLiftStreamsClient::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(&GameLiftStreamsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateStreamGroupOutcome UpdateStreamGroup(const Model::UpdateStreamGroupRequest& request) const;
 
  template <typename UpdateStreamGroupRequestT = Model::UpdateStreamGroupRequest>
  Model::UpdateStreamGroupOutcomeCallable UpdateStreamGroupCallable(const UpdateStreamGroupRequestT& request) const {
    return SubmitCallable(&GameLiftStreamsClient::UpdateStreamGroup, request);
  }
 
  template <typename UpdateStreamGroupRequestT = Model::UpdateStreamGroupRequest>
  void UpdateStreamGroupAsync(const UpdateStreamGroupRequestT& request, const UpdateStreamGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GameLiftStreamsClient::UpdateStreamGroup, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GameLiftStreamsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GameLiftStreamsClient>;
  void init(const GameLiftStreamsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GameLiftStreamsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  GameLiftStreamsClientConfiguration m_clientConfiguration;
  std::shared_ptr<GameLiftStreamsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GameLiftStreams
}  // namespace Aws