GameLiftStreamsClient.h

 
#pragma once
#include <aws/gameliftstreams/GameLiftStreams_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/gameliftstreams/GameLiftStreamsServiceClientModel.h>
 
namespace Aws
{
namespace GameLiftStreams
{
  class AWS_GAMELIFTSTREAMS_API GameLiftStreamsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GameLiftStreamsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GameLiftStreamsClient>;
      void init(const GameLiftStreamsClientConfiguration& clientConfiguration);
 
      GameLiftStreamsClientConfiguration m_clientConfiguration;
      std::shared_ptr<GameLiftStreamsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace GameLiftStreams
} // namespace Aws