ConnectParticipantClient.h

 
#pragma once
#include <aws/connectparticipant/ConnectParticipant_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/connectparticipant/ConnectParticipantServiceClientModel.h>
 
namespace Aws
{
namespace ConnectParticipant
{
  class AWS_CONNECTPARTICIPANT_API ConnectParticipantClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ConnectParticipantClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ConnectParticipantClientConfiguration ClientConfigurationType;
      typedef ConnectParticipantEndpointProvider EndpointProviderType;
 
        ConnectParticipantClient(const Aws::ConnectParticipant::ConnectParticipantClientConfiguration& clientConfiguration = Aws::ConnectParticipant::ConnectParticipantClientConfiguration(),
                                 std::shared_ptr<ConnectParticipantEndpointProviderBase> endpointProvider = nullptr);
 
        ConnectParticipantClient(const Aws::Auth::AWSCredentials& credentials,
                                 std::shared_ptr<ConnectParticipantEndpointProviderBase> endpointProvider = nullptr,
                                 const Aws::ConnectParticipant::ConnectParticipantClientConfiguration& clientConfiguration = Aws::ConnectParticipant::ConnectParticipantClientConfiguration());
 
        ConnectParticipantClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                 std::shared_ptr<ConnectParticipantEndpointProviderBase> endpointProvider = nullptr,
                                 const Aws::ConnectParticipant::ConnectParticipantClientConfiguration& clientConfiguration = Aws::ConnectParticipant::ConnectParticipantClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ConnectParticipantClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ConnectParticipantClient(const Aws::Auth::AWSCredentials& credentials,
                                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ConnectParticipantClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ConnectParticipantClient();
 
        virtual Model::CancelParticipantAuthenticationOutcome CancelParticipantAuthentication(const Model::CancelParticipantAuthenticationRequest& request) const;
 
        template<typename CancelParticipantAuthenticationRequestT = Model::CancelParticipantAuthenticationRequest>
        Model::CancelParticipantAuthenticationOutcomeCallable CancelParticipantAuthenticationCallable(const CancelParticipantAuthenticationRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::CancelParticipantAuthentication, request);
        }
 
        template<typename CancelParticipantAuthenticationRequestT = Model::CancelParticipantAuthenticationRequest>
        void CancelParticipantAuthenticationAsync(const CancelParticipantAuthenticationRequestT& request, const CancelParticipantAuthenticationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::CancelParticipantAuthentication, request, handler, context);
        }
 
        virtual Model::CompleteAttachmentUploadOutcome CompleteAttachmentUpload(const Model::CompleteAttachmentUploadRequest& request) const;
 
        template<typename CompleteAttachmentUploadRequestT = Model::CompleteAttachmentUploadRequest>
        Model::CompleteAttachmentUploadOutcomeCallable CompleteAttachmentUploadCallable(const CompleteAttachmentUploadRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::CompleteAttachmentUpload, request);
        }
 
        template<typename CompleteAttachmentUploadRequestT = Model::CompleteAttachmentUploadRequest>
        void CompleteAttachmentUploadAsync(const CompleteAttachmentUploadRequestT& request, const CompleteAttachmentUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::CompleteAttachmentUpload, request, handler, context);
        }
 
        virtual Model::CreateParticipantConnectionOutcome CreateParticipantConnection(const Model::CreateParticipantConnectionRequest& request) const;
 
        template<typename CreateParticipantConnectionRequestT = Model::CreateParticipantConnectionRequest>
        Model::CreateParticipantConnectionOutcomeCallable CreateParticipantConnectionCallable(const CreateParticipantConnectionRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::CreateParticipantConnection, request);
        }
 
        template<typename CreateParticipantConnectionRequestT = Model::CreateParticipantConnectionRequest>
        void CreateParticipantConnectionAsync(const CreateParticipantConnectionRequestT& request, const CreateParticipantConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::CreateParticipantConnection, request, handler, context);
        }
 
        virtual Model::DescribeViewOutcome DescribeView(const Model::DescribeViewRequest& request) const;
 
        template<typename DescribeViewRequestT = Model::DescribeViewRequest>
        Model::DescribeViewOutcomeCallable DescribeViewCallable(const DescribeViewRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::DescribeView, request);
        }
 
        template<typename DescribeViewRequestT = Model::DescribeViewRequest>
        void DescribeViewAsync(const DescribeViewRequestT& request, const DescribeViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::DescribeView, request, handler, context);
        }
 
        virtual Model::DisconnectParticipantOutcome DisconnectParticipant(const Model::DisconnectParticipantRequest& request) const;
 
        template<typename DisconnectParticipantRequestT = Model::DisconnectParticipantRequest>
        Model::DisconnectParticipantOutcomeCallable DisconnectParticipantCallable(const DisconnectParticipantRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::DisconnectParticipant, request);
        }
 
        template<typename DisconnectParticipantRequestT = Model::DisconnectParticipantRequest>
        void DisconnectParticipantAsync(const DisconnectParticipantRequestT& request, const DisconnectParticipantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::DisconnectParticipant, request, handler, context);
        }
 
        virtual Model::GetAttachmentOutcome GetAttachment(const Model::GetAttachmentRequest& request) const;
 
        template<typename GetAttachmentRequestT = Model::GetAttachmentRequest>
        Model::GetAttachmentOutcomeCallable GetAttachmentCallable(const GetAttachmentRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::GetAttachment, request);
        }
 
        template<typename GetAttachmentRequestT = Model::GetAttachmentRequest>
        void GetAttachmentAsync(const GetAttachmentRequestT& request, const GetAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::GetAttachment, request, handler, context);
        }
 
        virtual Model::GetAuthenticationUrlOutcome GetAuthenticationUrl(const Model::GetAuthenticationUrlRequest& request) const;
 
        template<typename GetAuthenticationUrlRequestT = Model::GetAuthenticationUrlRequest>
        Model::GetAuthenticationUrlOutcomeCallable GetAuthenticationUrlCallable(const GetAuthenticationUrlRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::GetAuthenticationUrl, request);
        }
 
        template<typename GetAuthenticationUrlRequestT = Model::GetAuthenticationUrlRequest>
        void GetAuthenticationUrlAsync(const GetAuthenticationUrlRequestT& request, const GetAuthenticationUrlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::GetAuthenticationUrl, request, handler, context);
        }
 
        virtual Model::GetTranscriptOutcome GetTranscript(const Model::GetTranscriptRequest& request) const;
 
        template<typename GetTranscriptRequestT = Model::GetTranscriptRequest>
        Model::GetTranscriptOutcomeCallable GetTranscriptCallable(const GetTranscriptRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::GetTranscript, request);
        }
 
        template<typename GetTranscriptRequestT = Model::GetTranscriptRequest>
        void GetTranscriptAsync(const GetTranscriptRequestT& request, const GetTranscriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::GetTranscript, 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(&ConnectParticipantClient::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(&ConnectParticipantClient::SendEvent, request, handler, context);
        }
 
        virtual Model::SendMessageOutcome SendMessage(const Model::SendMessageRequest& request) const;
 
        template<typename SendMessageRequestT = Model::SendMessageRequest>
        Model::SendMessageOutcomeCallable SendMessageCallable(const SendMessageRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::SendMessage, request);
        }
 
        template<typename SendMessageRequestT = Model::SendMessageRequest>
        void SendMessageAsync(const SendMessageRequestT& request, const SendMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::SendMessage, request, handler, context);
        }
 
        virtual Model::StartAttachmentUploadOutcome StartAttachmentUpload(const Model::StartAttachmentUploadRequest& request) const;
 
        template<typename StartAttachmentUploadRequestT = Model::StartAttachmentUploadRequest>
        Model::StartAttachmentUploadOutcomeCallable StartAttachmentUploadCallable(const StartAttachmentUploadRequestT& request) const
        {
            return SubmitCallable(&ConnectParticipantClient::StartAttachmentUpload, request);
        }
 
        template<typename StartAttachmentUploadRequestT = Model::StartAttachmentUploadRequest>
        void StartAttachmentUploadAsync(const StartAttachmentUploadRequestT& request, const StartAttachmentUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectParticipantClient::StartAttachmentUpload, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ConnectParticipantEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectParticipantClient>;
      void init(const ConnectParticipantClientConfiguration& clientConfiguration);
 
      ConnectParticipantClientConfiguration m_clientConfiguration;
      std::shared_ptr<ConnectParticipantEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ConnectParticipant
} // namespace Aws