IvschatClient.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/ivschat/IvschatServiceClientModel.h>
#include <aws/ivschat/Ivschat_EXPORTS.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