IvschatClient.h

 
#pragma once
#include <aws/ivschat/Ivschat_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/ivschat/IvschatServiceClientModel.h>
 
namespace Aws
{
namespace ivschat
{
  class AWS_IVSCHAT_API IvschatClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IvschatClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IvschatClientConfiguration ClientConfigurationType;
      typedef IvschatEndpointProvider EndpointProviderType;
 
        IvschatClient(const Aws::ivschat::IvschatClientConfiguration& clientConfiguration = Aws::ivschat::IvschatClientConfiguration(),
                      std::shared_ptr<IvschatEndpointProviderBase> endpointProvider = nullptr);
 
        IvschatClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<IvschatEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::ivschat::IvschatClientConfiguration& clientConfiguration = Aws::ivschat::IvschatClientConfiguration());
 
        IvschatClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<IvschatEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::ivschat::IvschatClientConfiguration& clientConfiguration = Aws::ivschat::IvschatClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IvschatClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IvschatClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IvschatClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IvschatClient();
 
        virtual Model::CreateChatTokenOutcome CreateChatToken(const Model::CreateChatTokenRequest& request) const;
 
        template<typename CreateChatTokenRequestT = Model::CreateChatTokenRequest>
        Model::CreateChatTokenOutcomeCallable CreateChatTokenCallable(const CreateChatTokenRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::CreateChatToken, request);
        }
 
        template<typename CreateChatTokenRequestT = Model::CreateChatTokenRequest>
        void CreateChatTokenAsync(const CreateChatTokenRequestT& request, const CreateChatTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::CreateChatToken, request, handler, context);
        }
 
        virtual Model::CreateLoggingConfigurationOutcome CreateLoggingConfiguration(const Model::CreateLoggingConfigurationRequest& request) const;
 
        template<typename CreateLoggingConfigurationRequestT = Model::CreateLoggingConfigurationRequest>
        Model::CreateLoggingConfigurationOutcomeCallable CreateLoggingConfigurationCallable(const CreateLoggingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::CreateLoggingConfiguration, request);
        }
 
        template<typename CreateLoggingConfigurationRequestT = Model::CreateLoggingConfigurationRequest>
        void CreateLoggingConfigurationAsync(const CreateLoggingConfigurationRequestT& request, const CreateLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::CreateLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::CreateRoomOutcome CreateRoom(const Model::CreateRoomRequest& request = {}) const;
 
        template<typename CreateRoomRequestT = Model::CreateRoomRequest>
        Model::CreateRoomOutcomeCallable CreateRoomCallable(const CreateRoomRequestT& request = {}) const
        {
            return SubmitCallable(&IvschatClient::CreateRoom, request);
        }
 
        template<typename CreateRoomRequestT = Model::CreateRoomRequest>
        void CreateRoomAsync(const CreateRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateRoomRequestT& request = {}) const
        {
            return SubmitAsync(&IvschatClient::CreateRoom, request, handler, context);
        }
 
        virtual Model::DeleteLoggingConfigurationOutcome DeleteLoggingConfiguration(const Model::DeleteLoggingConfigurationRequest& request) const;
 
        template<typename DeleteLoggingConfigurationRequestT = Model::DeleteLoggingConfigurationRequest>
        Model::DeleteLoggingConfigurationOutcomeCallable DeleteLoggingConfigurationCallable(const DeleteLoggingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::DeleteLoggingConfiguration, request);
        }
 
        template<typename DeleteLoggingConfigurationRequestT = Model::DeleteLoggingConfigurationRequest>
        void DeleteLoggingConfigurationAsync(const DeleteLoggingConfigurationRequestT& request, const DeleteLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::DeleteLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteMessageOutcome DeleteMessage(const Model::DeleteMessageRequest& request) const;
 
        template<typename DeleteMessageRequestT = Model::DeleteMessageRequest>
        Model::DeleteMessageOutcomeCallable DeleteMessageCallable(const DeleteMessageRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::DeleteMessage, request);
        }
 
        template<typename DeleteMessageRequestT = Model::DeleteMessageRequest>
        void DeleteMessageAsync(const DeleteMessageRequestT& request, const DeleteMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::DeleteMessage, request, handler, context);
        }
 
        virtual Model::DeleteRoomOutcome DeleteRoom(const Model::DeleteRoomRequest& request) const;
 
        template<typename DeleteRoomRequestT = Model::DeleteRoomRequest>
        Model::DeleteRoomOutcomeCallable DeleteRoomCallable(const DeleteRoomRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::DeleteRoom, request);
        }
 
        template<typename DeleteRoomRequestT = Model::DeleteRoomRequest>
        void DeleteRoomAsync(const DeleteRoomRequestT& request, const DeleteRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::DeleteRoom, request, handler, context);
        }
 
        virtual Model::DisconnectUserOutcome DisconnectUser(const Model::DisconnectUserRequest& request) const;
 
        template<typename DisconnectUserRequestT = Model::DisconnectUserRequest>
        Model::DisconnectUserOutcomeCallable DisconnectUserCallable(const DisconnectUserRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::DisconnectUser, request);
        }
 
        template<typename DisconnectUserRequestT = Model::DisconnectUserRequest>
        void DisconnectUserAsync(const DisconnectUserRequestT& request, const DisconnectUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::DisconnectUser, request, handler, context);
        }
 
        virtual Model::GetLoggingConfigurationOutcome GetLoggingConfiguration(const Model::GetLoggingConfigurationRequest& request) const;
 
        template<typename GetLoggingConfigurationRequestT = Model::GetLoggingConfigurationRequest>
        Model::GetLoggingConfigurationOutcomeCallable GetLoggingConfigurationCallable(const GetLoggingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::GetLoggingConfiguration, request);
        }
 
        template<typename GetLoggingConfigurationRequestT = Model::GetLoggingConfigurationRequest>
        void GetLoggingConfigurationAsync(const GetLoggingConfigurationRequestT& request, const GetLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::GetLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::GetRoomOutcome GetRoom(const Model::GetRoomRequest& request) const;
 
        template<typename GetRoomRequestT = Model::GetRoomRequest>
        Model::GetRoomOutcomeCallable GetRoomCallable(const GetRoomRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::GetRoom, request);
        }
 
        template<typename GetRoomRequestT = Model::GetRoomRequest>
        void GetRoomAsync(const GetRoomRequestT& request, const GetRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::GetRoom, request, handler, context);
        }
 
        virtual Model::ListLoggingConfigurationsOutcome ListLoggingConfigurations(const Model::ListLoggingConfigurationsRequest& request = {}) const;
 
        template<typename ListLoggingConfigurationsRequestT = Model::ListLoggingConfigurationsRequest>
        Model::ListLoggingConfigurationsOutcomeCallable ListLoggingConfigurationsCallable(const ListLoggingConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IvschatClient::ListLoggingConfigurations, request);
        }
 
        template<typename ListLoggingConfigurationsRequestT = Model::ListLoggingConfigurationsRequest>
        void ListLoggingConfigurationsAsync(const ListLoggingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLoggingConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IvschatClient::ListLoggingConfigurations, request, handler, context);
        }
 
        virtual Model::ListRoomsOutcome ListRooms(const Model::ListRoomsRequest& request = {}) const;
 
        template<typename ListRoomsRequestT = Model::ListRoomsRequest>
        Model::ListRoomsOutcomeCallable ListRoomsCallable(const ListRoomsRequestT& request = {}) const
        {
            return SubmitCallable(&IvschatClient::ListRooms, request);
        }
 
        template<typename ListRoomsRequestT = Model::ListRoomsRequest>
        void ListRoomsAsync(const ListRoomsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRoomsRequestT& request = {}) const
        {
            return SubmitAsync(&IvschatClient::ListRooms, 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(&IvschatClient::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(&IvschatClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::SendEventOutcome SendEvent(const Model::SendEventRequest& request) const;
 
        template<typename SendEventRequestT = Model::SendEventRequest>
        Model::SendEventOutcomeCallable SendEventCallable(const SendEventRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::SendEvent, request);
        }
 
        template<typename SendEventRequestT = Model::SendEventRequest>
        void SendEventAsync(const SendEventRequestT& request, const SendEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::SendEvent, 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(&IvschatClient::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(&IvschatClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::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(&IvschatClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateLoggingConfigurationOutcome UpdateLoggingConfiguration(const Model::UpdateLoggingConfigurationRequest& request) const;
 
        template<typename UpdateLoggingConfigurationRequestT = Model::UpdateLoggingConfigurationRequest>
        Model::UpdateLoggingConfigurationOutcomeCallable UpdateLoggingConfigurationCallable(const UpdateLoggingConfigurationRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::UpdateLoggingConfiguration, request);
        }
 
        template<typename UpdateLoggingConfigurationRequestT = Model::UpdateLoggingConfigurationRequest>
        void UpdateLoggingConfigurationAsync(const UpdateLoggingConfigurationRequestT& request, const UpdateLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::UpdateLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateRoomOutcome UpdateRoom(const Model::UpdateRoomRequest& request) const;
 
        template<typename UpdateRoomRequestT = Model::UpdateRoomRequest>
        Model::UpdateRoomOutcomeCallable UpdateRoomCallable(const UpdateRoomRequestT& request) const
        {
            return SubmitCallable(&IvschatClient::UpdateRoom, request);
        }
 
        template<typename UpdateRoomRequestT = Model::UpdateRoomRequest>
        void UpdateRoomAsync(const UpdateRoomRequestT& request, const UpdateRoomResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IvschatClient::UpdateRoom, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IvschatEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IvschatClient>;
      void init(const IvschatClientConfiguration& clientConfiguration);
 
      IvschatClientConfiguration m_clientConfiguration;
      std::shared_ptr<IvschatEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ivschat
} // namespace Aws