QConnectClient.h

 
#pragma once
#include <aws/qconnect/QConnect_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/qconnect/QConnectServiceClientModel.h>
 
namespace Aws
{
namespace QConnect
{
  class AWS_QCONNECT_API QConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<QConnectClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef QConnectClientConfiguration ClientConfigurationType;
      typedef QConnectEndpointProvider EndpointProviderType;
 
        QConnectClient(const Aws::QConnect::QConnectClientConfiguration& clientConfiguration = Aws::QConnect::QConnectClientConfiguration(),
                       std::shared_ptr<QConnectEndpointProviderBase> endpointProvider = nullptr);
 
        QConnectClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<QConnectEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::QConnect::QConnectClientConfiguration& clientConfiguration = Aws::QConnect::QConnectClientConfiguration());
 
        QConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<QConnectEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::QConnect::QConnectClientConfiguration& clientConfiguration = Aws::QConnect::QConnectClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        QConnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        QConnectClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        QConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~QConnectClient();
 
        virtual Model::ActivateMessageTemplateOutcome ActivateMessageTemplate(const Model::ActivateMessageTemplateRequest& request) const;
 
        template<typename ActivateMessageTemplateRequestT = Model::ActivateMessageTemplateRequest>
        Model::ActivateMessageTemplateOutcomeCallable ActivateMessageTemplateCallable(const ActivateMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ActivateMessageTemplate, request);
        }
 
        template<typename ActivateMessageTemplateRequestT = Model::ActivateMessageTemplateRequest>
        void ActivateMessageTemplateAsync(const ActivateMessageTemplateRequestT& request, const ActivateMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ActivateMessageTemplate, request, handler, context);
        }
 
        virtual Model::CreateAIAgentOutcome CreateAIAgent(const Model::CreateAIAgentRequest& request) const;
 
        template<typename CreateAIAgentRequestT = Model::CreateAIAgentRequest>
        Model::CreateAIAgentOutcomeCallable CreateAIAgentCallable(const CreateAIAgentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAIAgent, request);
        }
 
        template<typename CreateAIAgentRequestT = Model::CreateAIAgentRequest>
        void CreateAIAgentAsync(const CreateAIAgentRequestT& request, const CreateAIAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAIAgent, request, handler, context);
        }
 
        virtual Model::CreateAIAgentVersionOutcome CreateAIAgentVersion(const Model::CreateAIAgentVersionRequest& request) const;
 
        template<typename CreateAIAgentVersionRequestT = Model::CreateAIAgentVersionRequest>
        Model::CreateAIAgentVersionOutcomeCallable CreateAIAgentVersionCallable(const CreateAIAgentVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAIAgentVersion, request);
        }
 
        template<typename CreateAIAgentVersionRequestT = Model::CreateAIAgentVersionRequest>
        void CreateAIAgentVersionAsync(const CreateAIAgentVersionRequestT& request, const CreateAIAgentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAIAgentVersion, request, handler, context);
        }
 
        virtual Model::CreateAIGuardrailOutcome CreateAIGuardrail(const Model::CreateAIGuardrailRequest& request) const;
 
        template<typename CreateAIGuardrailRequestT = Model::CreateAIGuardrailRequest>
        Model::CreateAIGuardrailOutcomeCallable CreateAIGuardrailCallable(const CreateAIGuardrailRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAIGuardrail, request);
        }
 
        template<typename CreateAIGuardrailRequestT = Model::CreateAIGuardrailRequest>
        void CreateAIGuardrailAsync(const CreateAIGuardrailRequestT& request, const CreateAIGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAIGuardrail, request, handler, context);
        }
 
        virtual Model::CreateAIGuardrailVersionOutcome CreateAIGuardrailVersion(const Model::CreateAIGuardrailVersionRequest& request) const;
 
        template<typename CreateAIGuardrailVersionRequestT = Model::CreateAIGuardrailVersionRequest>
        Model::CreateAIGuardrailVersionOutcomeCallable CreateAIGuardrailVersionCallable(const CreateAIGuardrailVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAIGuardrailVersion, request);
        }
 
        template<typename CreateAIGuardrailVersionRequestT = Model::CreateAIGuardrailVersionRequest>
        void CreateAIGuardrailVersionAsync(const CreateAIGuardrailVersionRequestT& request, const CreateAIGuardrailVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAIGuardrailVersion, request, handler, context);
        }
 
        virtual Model::CreateAIPromptOutcome CreateAIPrompt(const Model::CreateAIPromptRequest& request) const;
 
        template<typename CreateAIPromptRequestT = Model::CreateAIPromptRequest>
        Model::CreateAIPromptOutcomeCallable CreateAIPromptCallable(const CreateAIPromptRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAIPrompt, request);
        }
 
        template<typename CreateAIPromptRequestT = Model::CreateAIPromptRequest>
        void CreateAIPromptAsync(const CreateAIPromptRequestT& request, const CreateAIPromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAIPrompt, request, handler, context);
        }
 
        virtual Model::CreateAIPromptVersionOutcome CreateAIPromptVersion(const Model::CreateAIPromptVersionRequest& request) const;
 
        template<typename CreateAIPromptVersionRequestT = Model::CreateAIPromptVersionRequest>
        Model::CreateAIPromptVersionOutcomeCallable CreateAIPromptVersionCallable(const CreateAIPromptVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAIPromptVersion, request);
        }
 
        template<typename CreateAIPromptVersionRequestT = Model::CreateAIPromptVersionRequest>
        void CreateAIPromptVersionAsync(const CreateAIPromptVersionRequestT& request, const CreateAIPromptVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAIPromptVersion, request, handler, context);
        }
 
        virtual Model::CreateAssistantOutcome CreateAssistant(const Model::CreateAssistantRequest& request) const;
 
        template<typename CreateAssistantRequestT = Model::CreateAssistantRequest>
        Model::CreateAssistantOutcomeCallable CreateAssistantCallable(const CreateAssistantRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAssistant, request);
        }
 
        template<typename CreateAssistantRequestT = Model::CreateAssistantRequest>
        void CreateAssistantAsync(const CreateAssistantRequestT& request, const CreateAssistantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAssistant, request, handler, context);
        }
 
        virtual Model::CreateAssistantAssociationOutcome CreateAssistantAssociation(const Model::CreateAssistantAssociationRequest& request) const;
 
        template<typename CreateAssistantAssociationRequestT = Model::CreateAssistantAssociationRequest>
        Model::CreateAssistantAssociationOutcomeCallable CreateAssistantAssociationCallable(const CreateAssistantAssociationRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateAssistantAssociation, request);
        }
 
        template<typename CreateAssistantAssociationRequestT = Model::CreateAssistantAssociationRequest>
        void CreateAssistantAssociationAsync(const CreateAssistantAssociationRequestT& request, const CreateAssistantAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateAssistantAssociation, request, handler, context);
        }
 
        virtual Model::CreateContentOutcome CreateContent(const Model::CreateContentRequest& request) const;
 
        template<typename CreateContentRequestT = Model::CreateContentRequest>
        Model::CreateContentOutcomeCallable CreateContentCallable(const CreateContentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateContent, request);
        }
 
        template<typename CreateContentRequestT = Model::CreateContentRequest>
        void CreateContentAsync(const CreateContentRequestT& request, const CreateContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateContent, request, handler, context);
        }
 
        virtual Model::CreateContentAssociationOutcome CreateContentAssociation(const Model::CreateContentAssociationRequest& request) const;
 
        template<typename CreateContentAssociationRequestT = Model::CreateContentAssociationRequest>
        Model::CreateContentAssociationOutcomeCallable CreateContentAssociationCallable(const CreateContentAssociationRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateContentAssociation, request);
        }
 
        template<typename CreateContentAssociationRequestT = Model::CreateContentAssociationRequest>
        void CreateContentAssociationAsync(const CreateContentAssociationRequestT& request, const CreateContentAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateContentAssociation, request, handler, context);
        }
 
        virtual Model::CreateKnowledgeBaseOutcome CreateKnowledgeBase(const Model::CreateKnowledgeBaseRequest& request) const;
 
        template<typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
        Model::CreateKnowledgeBaseOutcomeCallable CreateKnowledgeBaseCallable(const CreateKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateKnowledgeBase, request);
        }
 
        template<typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
        void CreateKnowledgeBaseAsync(const CreateKnowledgeBaseRequestT& request, const CreateKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateKnowledgeBase, request, handler, context);
        }
 
        virtual Model::CreateMessageTemplateOutcome CreateMessageTemplate(const Model::CreateMessageTemplateRequest& request) const;
 
        template<typename CreateMessageTemplateRequestT = Model::CreateMessageTemplateRequest>
        Model::CreateMessageTemplateOutcomeCallable CreateMessageTemplateCallable(const CreateMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateMessageTemplate, request);
        }
 
        template<typename CreateMessageTemplateRequestT = Model::CreateMessageTemplateRequest>
        void CreateMessageTemplateAsync(const CreateMessageTemplateRequestT& request, const CreateMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateMessageTemplate, request, handler, context);
        }
 
        virtual Model::CreateMessageTemplateAttachmentOutcome CreateMessageTemplateAttachment(const Model::CreateMessageTemplateAttachmentRequest& request) const;
 
        template<typename CreateMessageTemplateAttachmentRequestT = Model::CreateMessageTemplateAttachmentRequest>
        Model::CreateMessageTemplateAttachmentOutcomeCallable CreateMessageTemplateAttachmentCallable(const CreateMessageTemplateAttachmentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateMessageTemplateAttachment, request);
        }
 
        template<typename CreateMessageTemplateAttachmentRequestT = Model::CreateMessageTemplateAttachmentRequest>
        void CreateMessageTemplateAttachmentAsync(const CreateMessageTemplateAttachmentRequestT& request, const CreateMessageTemplateAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateMessageTemplateAttachment, request, handler, context);
        }
 
        virtual Model::CreateMessageTemplateVersionOutcome CreateMessageTemplateVersion(const Model::CreateMessageTemplateVersionRequest& request) const;
 
        template<typename CreateMessageTemplateVersionRequestT = Model::CreateMessageTemplateVersionRequest>
        Model::CreateMessageTemplateVersionOutcomeCallable CreateMessageTemplateVersionCallable(const CreateMessageTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateMessageTemplateVersion, request);
        }
 
        template<typename CreateMessageTemplateVersionRequestT = Model::CreateMessageTemplateVersionRequest>
        void CreateMessageTemplateVersionAsync(const CreateMessageTemplateVersionRequestT& request, const CreateMessageTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateMessageTemplateVersion, request, handler, context);
        }
 
        virtual Model::CreateQuickResponseOutcome CreateQuickResponse(const Model::CreateQuickResponseRequest& request) const;
 
        template<typename CreateQuickResponseRequestT = Model::CreateQuickResponseRequest>
        Model::CreateQuickResponseOutcomeCallable CreateQuickResponseCallable(const CreateQuickResponseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateQuickResponse, request);
        }
 
        template<typename CreateQuickResponseRequestT = Model::CreateQuickResponseRequest>
        void CreateQuickResponseAsync(const CreateQuickResponseRequestT& request, const CreateQuickResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateQuickResponse, request, handler, context);
        }
 
        virtual Model::CreateSessionOutcome CreateSession(const Model::CreateSessionRequest& request) const;
 
        template<typename CreateSessionRequestT = Model::CreateSessionRequest>
        Model::CreateSessionOutcomeCallable CreateSessionCallable(const CreateSessionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::CreateSession, request);
        }
 
        template<typename CreateSessionRequestT = Model::CreateSessionRequest>
        void CreateSessionAsync(const CreateSessionRequestT& request, const CreateSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::CreateSession, request, handler, context);
        }
 
        virtual Model::DeactivateMessageTemplateOutcome DeactivateMessageTemplate(const Model::DeactivateMessageTemplateRequest& request) const;
 
        template<typename DeactivateMessageTemplateRequestT = Model::DeactivateMessageTemplateRequest>
        Model::DeactivateMessageTemplateOutcomeCallable DeactivateMessageTemplateCallable(const DeactivateMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeactivateMessageTemplate, request);
        }
 
        template<typename DeactivateMessageTemplateRequestT = Model::DeactivateMessageTemplateRequest>
        void DeactivateMessageTemplateAsync(const DeactivateMessageTemplateRequestT& request, const DeactivateMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeactivateMessageTemplate, request, handler, context);
        }
 
        virtual Model::DeleteAIAgentOutcome DeleteAIAgent(const Model::DeleteAIAgentRequest& request) const;
 
        template<typename DeleteAIAgentRequestT = Model::DeleteAIAgentRequest>
        Model::DeleteAIAgentOutcomeCallable DeleteAIAgentCallable(const DeleteAIAgentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAIAgent, request);
        }
 
        template<typename DeleteAIAgentRequestT = Model::DeleteAIAgentRequest>
        void DeleteAIAgentAsync(const DeleteAIAgentRequestT& request, const DeleteAIAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAIAgent, request, handler, context);
        }
 
        virtual Model::DeleteAIAgentVersionOutcome DeleteAIAgentVersion(const Model::DeleteAIAgentVersionRequest& request) const;
 
        template<typename DeleteAIAgentVersionRequestT = Model::DeleteAIAgentVersionRequest>
        Model::DeleteAIAgentVersionOutcomeCallable DeleteAIAgentVersionCallable(const DeleteAIAgentVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAIAgentVersion, request);
        }
 
        template<typename DeleteAIAgentVersionRequestT = Model::DeleteAIAgentVersionRequest>
        void DeleteAIAgentVersionAsync(const DeleteAIAgentVersionRequestT& request, const DeleteAIAgentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAIAgentVersion, request, handler, context);
        }
 
        virtual Model::DeleteAIGuardrailOutcome DeleteAIGuardrail(const Model::DeleteAIGuardrailRequest& request) const;
 
        template<typename DeleteAIGuardrailRequestT = Model::DeleteAIGuardrailRequest>
        Model::DeleteAIGuardrailOutcomeCallable DeleteAIGuardrailCallable(const DeleteAIGuardrailRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAIGuardrail, request);
        }
 
        template<typename DeleteAIGuardrailRequestT = Model::DeleteAIGuardrailRequest>
        void DeleteAIGuardrailAsync(const DeleteAIGuardrailRequestT& request, const DeleteAIGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAIGuardrail, request, handler, context);
        }
 
        virtual Model::DeleteAIGuardrailVersionOutcome DeleteAIGuardrailVersion(const Model::DeleteAIGuardrailVersionRequest& request) const;
 
        template<typename DeleteAIGuardrailVersionRequestT = Model::DeleteAIGuardrailVersionRequest>
        Model::DeleteAIGuardrailVersionOutcomeCallable DeleteAIGuardrailVersionCallable(const DeleteAIGuardrailVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAIGuardrailVersion, request);
        }
 
        template<typename DeleteAIGuardrailVersionRequestT = Model::DeleteAIGuardrailVersionRequest>
        void DeleteAIGuardrailVersionAsync(const DeleteAIGuardrailVersionRequestT& request, const DeleteAIGuardrailVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAIGuardrailVersion, request, handler, context);
        }
 
        virtual Model::DeleteAIPromptOutcome DeleteAIPrompt(const Model::DeleteAIPromptRequest& request) const;
 
        template<typename DeleteAIPromptRequestT = Model::DeleteAIPromptRequest>
        Model::DeleteAIPromptOutcomeCallable DeleteAIPromptCallable(const DeleteAIPromptRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAIPrompt, request);
        }
 
        template<typename DeleteAIPromptRequestT = Model::DeleteAIPromptRequest>
        void DeleteAIPromptAsync(const DeleteAIPromptRequestT& request, const DeleteAIPromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAIPrompt, request, handler, context);
        }
 
        virtual Model::DeleteAIPromptVersionOutcome DeleteAIPromptVersion(const Model::DeleteAIPromptVersionRequest& request) const;
 
        template<typename DeleteAIPromptVersionRequestT = Model::DeleteAIPromptVersionRequest>
        Model::DeleteAIPromptVersionOutcomeCallable DeleteAIPromptVersionCallable(const DeleteAIPromptVersionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAIPromptVersion, request);
        }
 
        template<typename DeleteAIPromptVersionRequestT = Model::DeleteAIPromptVersionRequest>
        void DeleteAIPromptVersionAsync(const DeleteAIPromptVersionRequestT& request, const DeleteAIPromptVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAIPromptVersion, request, handler, context);
        }
 
        virtual Model::DeleteAssistantOutcome DeleteAssistant(const Model::DeleteAssistantRequest& request) const;
 
        template<typename DeleteAssistantRequestT = Model::DeleteAssistantRequest>
        Model::DeleteAssistantOutcomeCallable DeleteAssistantCallable(const DeleteAssistantRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAssistant, request);
        }
 
        template<typename DeleteAssistantRequestT = Model::DeleteAssistantRequest>
        void DeleteAssistantAsync(const DeleteAssistantRequestT& request, const DeleteAssistantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAssistant, request, handler, context);
        }
 
        virtual Model::DeleteAssistantAssociationOutcome DeleteAssistantAssociation(const Model::DeleteAssistantAssociationRequest& request) const;
 
        template<typename DeleteAssistantAssociationRequestT = Model::DeleteAssistantAssociationRequest>
        Model::DeleteAssistantAssociationOutcomeCallable DeleteAssistantAssociationCallable(const DeleteAssistantAssociationRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteAssistantAssociation, request);
        }
 
        template<typename DeleteAssistantAssociationRequestT = Model::DeleteAssistantAssociationRequest>
        void DeleteAssistantAssociationAsync(const DeleteAssistantAssociationRequestT& request, const DeleteAssistantAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteAssistantAssociation, request, handler, context);
        }
 
        virtual Model::DeleteContentOutcome DeleteContent(const Model::DeleteContentRequest& request) const;
 
        template<typename DeleteContentRequestT = Model::DeleteContentRequest>
        Model::DeleteContentOutcomeCallable DeleteContentCallable(const DeleteContentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteContent, request);
        }
 
        template<typename DeleteContentRequestT = Model::DeleteContentRequest>
        void DeleteContentAsync(const DeleteContentRequestT& request, const DeleteContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteContent, request, handler, context);
        }
 
        virtual Model::DeleteContentAssociationOutcome DeleteContentAssociation(const Model::DeleteContentAssociationRequest& request) const;
 
        template<typename DeleteContentAssociationRequestT = Model::DeleteContentAssociationRequest>
        Model::DeleteContentAssociationOutcomeCallable DeleteContentAssociationCallable(const DeleteContentAssociationRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteContentAssociation, request);
        }
 
        template<typename DeleteContentAssociationRequestT = Model::DeleteContentAssociationRequest>
        void DeleteContentAssociationAsync(const DeleteContentAssociationRequestT& request, const DeleteContentAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteContentAssociation, request, handler, context);
        }
 
        virtual Model::DeleteImportJobOutcome DeleteImportJob(const Model::DeleteImportJobRequest& request) const;
 
        template<typename DeleteImportJobRequestT = Model::DeleteImportJobRequest>
        Model::DeleteImportJobOutcomeCallable DeleteImportJobCallable(const DeleteImportJobRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteImportJob, request);
        }
 
        template<typename DeleteImportJobRequestT = Model::DeleteImportJobRequest>
        void DeleteImportJobAsync(const DeleteImportJobRequestT& request, const DeleteImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteImportJob, request, handler, context);
        }
 
        virtual Model::DeleteKnowledgeBaseOutcome DeleteKnowledgeBase(const Model::DeleteKnowledgeBaseRequest& request) const;
 
        template<typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
        Model::DeleteKnowledgeBaseOutcomeCallable DeleteKnowledgeBaseCallable(const DeleteKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteKnowledgeBase, request);
        }
 
        template<typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
        void DeleteKnowledgeBaseAsync(const DeleteKnowledgeBaseRequestT& request, const DeleteKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteKnowledgeBase, request, handler, context);
        }
 
        virtual Model::DeleteMessageTemplateOutcome DeleteMessageTemplate(const Model::DeleteMessageTemplateRequest& request) const;
 
        template<typename DeleteMessageTemplateRequestT = Model::DeleteMessageTemplateRequest>
        Model::DeleteMessageTemplateOutcomeCallable DeleteMessageTemplateCallable(const DeleteMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteMessageTemplate, request);
        }
 
        template<typename DeleteMessageTemplateRequestT = Model::DeleteMessageTemplateRequest>
        void DeleteMessageTemplateAsync(const DeleteMessageTemplateRequestT& request, const DeleteMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteMessageTemplate, request, handler, context);
        }
 
        virtual Model::DeleteMessageTemplateAttachmentOutcome DeleteMessageTemplateAttachment(const Model::DeleteMessageTemplateAttachmentRequest& request) const;
 
        template<typename DeleteMessageTemplateAttachmentRequestT = Model::DeleteMessageTemplateAttachmentRequest>
        Model::DeleteMessageTemplateAttachmentOutcomeCallable DeleteMessageTemplateAttachmentCallable(const DeleteMessageTemplateAttachmentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteMessageTemplateAttachment, request);
        }
 
        template<typename DeleteMessageTemplateAttachmentRequestT = Model::DeleteMessageTemplateAttachmentRequest>
        void DeleteMessageTemplateAttachmentAsync(const DeleteMessageTemplateAttachmentRequestT& request, const DeleteMessageTemplateAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteMessageTemplateAttachment, request, handler, context);
        }
 
        virtual Model::DeleteQuickResponseOutcome DeleteQuickResponse(const Model::DeleteQuickResponseRequest& request) const;
 
        template<typename DeleteQuickResponseRequestT = Model::DeleteQuickResponseRequest>
        Model::DeleteQuickResponseOutcomeCallable DeleteQuickResponseCallable(const DeleteQuickResponseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::DeleteQuickResponse, request);
        }
 
        template<typename DeleteQuickResponseRequestT = Model::DeleteQuickResponseRequest>
        void DeleteQuickResponseAsync(const DeleteQuickResponseRequestT& request, const DeleteQuickResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::DeleteQuickResponse, request, handler, context);
        }
 
        virtual Model::GetAIAgentOutcome GetAIAgent(const Model::GetAIAgentRequest& request) const;
 
        template<typename GetAIAgentRequestT = Model::GetAIAgentRequest>
        Model::GetAIAgentOutcomeCallable GetAIAgentCallable(const GetAIAgentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetAIAgent, request);
        }
 
        template<typename GetAIAgentRequestT = Model::GetAIAgentRequest>
        void GetAIAgentAsync(const GetAIAgentRequestT& request, const GetAIAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetAIAgent, request, handler, context);
        }
 
        virtual Model::GetAIGuardrailOutcome GetAIGuardrail(const Model::GetAIGuardrailRequest& request) const;
 
        template<typename GetAIGuardrailRequestT = Model::GetAIGuardrailRequest>
        Model::GetAIGuardrailOutcomeCallable GetAIGuardrailCallable(const GetAIGuardrailRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetAIGuardrail, request);
        }
 
        template<typename GetAIGuardrailRequestT = Model::GetAIGuardrailRequest>
        void GetAIGuardrailAsync(const GetAIGuardrailRequestT& request, const GetAIGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetAIGuardrail, request, handler, context);
        }
 
        virtual Model::GetAIPromptOutcome GetAIPrompt(const Model::GetAIPromptRequest& request) const;
 
        template<typename GetAIPromptRequestT = Model::GetAIPromptRequest>
        Model::GetAIPromptOutcomeCallable GetAIPromptCallable(const GetAIPromptRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetAIPrompt, request);
        }
 
        template<typename GetAIPromptRequestT = Model::GetAIPromptRequest>
        void GetAIPromptAsync(const GetAIPromptRequestT& request, const GetAIPromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetAIPrompt, request, handler, context);
        }
 
        virtual Model::GetAssistantOutcome GetAssistant(const Model::GetAssistantRequest& request) const;
 
        template<typename GetAssistantRequestT = Model::GetAssistantRequest>
        Model::GetAssistantOutcomeCallable GetAssistantCallable(const GetAssistantRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetAssistant, request);
        }
 
        template<typename GetAssistantRequestT = Model::GetAssistantRequest>
        void GetAssistantAsync(const GetAssistantRequestT& request, const GetAssistantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetAssistant, request, handler, context);
        }
 
        virtual Model::GetAssistantAssociationOutcome GetAssistantAssociation(const Model::GetAssistantAssociationRequest& request) const;
 
        template<typename GetAssistantAssociationRequestT = Model::GetAssistantAssociationRequest>
        Model::GetAssistantAssociationOutcomeCallable GetAssistantAssociationCallable(const GetAssistantAssociationRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetAssistantAssociation, request);
        }
 
        template<typename GetAssistantAssociationRequestT = Model::GetAssistantAssociationRequest>
        void GetAssistantAssociationAsync(const GetAssistantAssociationRequestT& request, const GetAssistantAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetAssistantAssociation, request, handler, context);
        }
 
        virtual Model::GetContentOutcome GetContent(const Model::GetContentRequest& request) const;
 
        template<typename GetContentRequestT = Model::GetContentRequest>
        Model::GetContentOutcomeCallable GetContentCallable(const GetContentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetContent, request);
        }
 
        template<typename GetContentRequestT = Model::GetContentRequest>
        void GetContentAsync(const GetContentRequestT& request, const GetContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetContent, request, handler, context);
        }
 
        virtual Model::GetContentAssociationOutcome GetContentAssociation(const Model::GetContentAssociationRequest& request) const;
 
        template<typename GetContentAssociationRequestT = Model::GetContentAssociationRequest>
        Model::GetContentAssociationOutcomeCallable GetContentAssociationCallable(const GetContentAssociationRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetContentAssociation, request);
        }
 
        template<typename GetContentAssociationRequestT = Model::GetContentAssociationRequest>
        void GetContentAssociationAsync(const GetContentAssociationRequestT& request, const GetContentAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetContentAssociation, request, handler, context);
        }
 
        virtual Model::GetContentSummaryOutcome GetContentSummary(const Model::GetContentSummaryRequest& request) const;
 
        template<typename GetContentSummaryRequestT = Model::GetContentSummaryRequest>
        Model::GetContentSummaryOutcomeCallable GetContentSummaryCallable(const GetContentSummaryRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetContentSummary, request);
        }
 
        template<typename GetContentSummaryRequestT = Model::GetContentSummaryRequest>
        void GetContentSummaryAsync(const GetContentSummaryRequestT& request, const GetContentSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetContentSummary, request, handler, context);
        }
 
        virtual Model::GetImportJobOutcome GetImportJob(const Model::GetImportJobRequest& request) const;
 
        template<typename GetImportJobRequestT = Model::GetImportJobRequest>
        Model::GetImportJobOutcomeCallable GetImportJobCallable(const GetImportJobRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetImportJob, request);
        }
 
        template<typename GetImportJobRequestT = Model::GetImportJobRequest>
        void GetImportJobAsync(const GetImportJobRequestT& request, const GetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetImportJob, request, handler, context);
        }
 
        virtual Model::GetKnowledgeBaseOutcome GetKnowledgeBase(const Model::GetKnowledgeBaseRequest& request) const;
 
        template<typename GetKnowledgeBaseRequestT = Model::GetKnowledgeBaseRequest>
        Model::GetKnowledgeBaseOutcomeCallable GetKnowledgeBaseCallable(const GetKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetKnowledgeBase, request);
        }
 
        template<typename GetKnowledgeBaseRequestT = Model::GetKnowledgeBaseRequest>
        void GetKnowledgeBaseAsync(const GetKnowledgeBaseRequestT& request, const GetKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetKnowledgeBase, request, handler, context);
        }
 
        virtual Model::GetMessageTemplateOutcome GetMessageTemplate(const Model::GetMessageTemplateRequest& request) const;
 
        template<typename GetMessageTemplateRequestT = Model::GetMessageTemplateRequest>
        Model::GetMessageTemplateOutcomeCallable GetMessageTemplateCallable(const GetMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetMessageTemplate, request);
        }
 
        template<typename GetMessageTemplateRequestT = Model::GetMessageTemplateRequest>
        void GetMessageTemplateAsync(const GetMessageTemplateRequestT& request, const GetMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetMessageTemplate, request, handler, context);
        }
 
        virtual Model::GetNextMessageOutcome GetNextMessage(const Model::GetNextMessageRequest& request) const;
 
        template<typename GetNextMessageRequestT = Model::GetNextMessageRequest>
        Model::GetNextMessageOutcomeCallable GetNextMessageCallable(const GetNextMessageRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetNextMessage, request);
        }
 
        template<typename GetNextMessageRequestT = Model::GetNextMessageRequest>
        void GetNextMessageAsync(const GetNextMessageRequestT& request, const GetNextMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetNextMessage, request, handler, context);
        }
 
        virtual Model::GetQuickResponseOutcome GetQuickResponse(const Model::GetQuickResponseRequest& request) const;
 
        template<typename GetQuickResponseRequestT = Model::GetQuickResponseRequest>
        Model::GetQuickResponseOutcomeCallable GetQuickResponseCallable(const GetQuickResponseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetQuickResponse, request);
        }
 
        template<typename GetQuickResponseRequestT = Model::GetQuickResponseRequest>
        void GetQuickResponseAsync(const GetQuickResponseRequestT& request, const GetQuickResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetQuickResponse, request, handler, context);
        }
 
        virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
        template<typename GetSessionRequestT = Model::GetSessionRequest>
        Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::GetSession, request);
        }
 
        template<typename GetSessionRequestT = Model::GetSessionRequest>
        void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::GetSession, request, handler, context);
        }
 
        virtual Model::ListAIAgentVersionsOutcome ListAIAgentVersions(const Model::ListAIAgentVersionsRequest& request) const;
 
        template<typename ListAIAgentVersionsRequestT = Model::ListAIAgentVersionsRequest>
        Model::ListAIAgentVersionsOutcomeCallable ListAIAgentVersionsCallable(const ListAIAgentVersionsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAIAgentVersions, request);
        }
 
        template<typename ListAIAgentVersionsRequestT = Model::ListAIAgentVersionsRequest>
        void ListAIAgentVersionsAsync(const ListAIAgentVersionsRequestT& request, const ListAIAgentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAIAgentVersions, request, handler, context);
        }
 
        virtual Model::ListAIAgentsOutcome ListAIAgents(const Model::ListAIAgentsRequest& request) const;
 
        template<typename ListAIAgentsRequestT = Model::ListAIAgentsRequest>
        Model::ListAIAgentsOutcomeCallable ListAIAgentsCallable(const ListAIAgentsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAIAgents, request);
        }
 
        template<typename ListAIAgentsRequestT = Model::ListAIAgentsRequest>
        void ListAIAgentsAsync(const ListAIAgentsRequestT& request, const ListAIAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAIAgents, request, handler, context);
        }
 
        virtual Model::ListAIGuardrailVersionsOutcome ListAIGuardrailVersions(const Model::ListAIGuardrailVersionsRequest& request) const;
 
        template<typename ListAIGuardrailVersionsRequestT = Model::ListAIGuardrailVersionsRequest>
        Model::ListAIGuardrailVersionsOutcomeCallable ListAIGuardrailVersionsCallable(const ListAIGuardrailVersionsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAIGuardrailVersions, request);
        }
 
        template<typename ListAIGuardrailVersionsRequestT = Model::ListAIGuardrailVersionsRequest>
        void ListAIGuardrailVersionsAsync(const ListAIGuardrailVersionsRequestT& request, const ListAIGuardrailVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAIGuardrailVersions, request, handler, context);
        }
 
        virtual Model::ListAIGuardrailsOutcome ListAIGuardrails(const Model::ListAIGuardrailsRequest& request) const;
 
        template<typename ListAIGuardrailsRequestT = Model::ListAIGuardrailsRequest>
        Model::ListAIGuardrailsOutcomeCallable ListAIGuardrailsCallable(const ListAIGuardrailsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAIGuardrails, request);
        }
 
        template<typename ListAIGuardrailsRequestT = Model::ListAIGuardrailsRequest>
        void ListAIGuardrailsAsync(const ListAIGuardrailsRequestT& request, const ListAIGuardrailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAIGuardrails, request, handler, context);
        }
 
        virtual Model::ListAIPromptVersionsOutcome ListAIPromptVersions(const Model::ListAIPromptVersionsRequest& request) const;
 
        template<typename ListAIPromptVersionsRequestT = Model::ListAIPromptVersionsRequest>
        Model::ListAIPromptVersionsOutcomeCallable ListAIPromptVersionsCallable(const ListAIPromptVersionsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAIPromptVersions, request);
        }
 
        template<typename ListAIPromptVersionsRequestT = Model::ListAIPromptVersionsRequest>
        void ListAIPromptVersionsAsync(const ListAIPromptVersionsRequestT& request, const ListAIPromptVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAIPromptVersions, request, handler, context);
        }
 
        virtual Model::ListAIPromptsOutcome ListAIPrompts(const Model::ListAIPromptsRequest& request) const;
 
        template<typename ListAIPromptsRequestT = Model::ListAIPromptsRequest>
        Model::ListAIPromptsOutcomeCallable ListAIPromptsCallable(const ListAIPromptsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAIPrompts, request);
        }
 
        template<typename ListAIPromptsRequestT = Model::ListAIPromptsRequest>
        void ListAIPromptsAsync(const ListAIPromptsRequestT& request, const ListAIPromptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAIPrompts, request, handler, context);
        }
 
        virtual Model::ListAssistantAssociationsOutcome ListAssistantAssociations(const Model::ListAssistantAssociationsRequest& request) const;
 
        template<typename ListAssistantAssociationsRequestT = Model::ListAssistantAssociationsRequest>
        Model::ListAssistantAssociationsOutcomeCallable ListAssistantAssociationsCallable(const ListAssistantAssociationsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListAssistantAssociations, request);
        }
 
        template<typename ListAssistantAssociationsRequestT = Model::ListAssistantAssociationsRequest>
        void ListAssistantAssociationsAsync(const ListAssistantAssociationsRequestT& request, const ListAssistantAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListAssistantAssociations, request, handler, context);
        }
 
        virtual Model::ListAssistantsOutcome ListAssistants(const Model::ListAssistantsRequest& request = {}) const;
 
        template<typename ListAssistantsRequestT = Model::ListAssistantsRequest>
        Model::ListAssistantsOutcomeCallable ListAssistantsCallable(const ListAssistantsRequestT& request = {}) const
        {
            return SubmitCallable(&QConnectClient::ListAssistants, request);
        }
 
        template<typename ListAssistantsRequestT = Model::ListAssistantsRequest>
        void ListAssistantsAsync(const ListAssistantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAssistantsRequestT& request = {}) const
        {
            return SubmitAsync(&QConnectClient::ListAssistants, request, handler, context);
        }
 
        virtual Model::ListContentAssociationsOutcome ListContentAssociations(const Model::ListContentAssociationsRequest& request) const;
 
        template<typename ListContentAssociationsRequestT = Model::ListContentAssociationsRequest>
        Model::ListContentAssociationsOutcomeCallable ListContentAssociationsCallable(const ListContentAssociationsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListContentAssociations, request);
        }
 
        template<typename ListContentAssociationsRequestT = Model::ListContentAssociationsRequest>
        void ListContentAssociationsAsync(const ListContentAssociationsRequestT& request, const ListContentAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListContentAssociations, request, handler, context);
        }
 
        virtual Model::ListContentsOutcome ListContents(const Model::ListContentsRequest& request) const;
 
        template<typename ListContentsRequestT = Model::ListContentsRequest>
        Model::ListContentsOutcomeCallable ListContentsCallable(const ListContentsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListContents, request);
        }
 
        template<typename ListContentsRequestT = Model::ListContentsRequest>
        void ListContentsAsync(const ListContentsRequestT& request, const ListContentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListContents, request, handler, context);
        }
 
        virtual Model::ListImportJobsOutcome ListImportJobs(const Model::ListImportJobsRequest& request) const;
 
        template<typename ListImportJobsRequestT = Model::ListImportJobsRequest>
        Model::ListImportJobsOutcomeCallable ListImportJobsCallable(const ListImportJobsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListImportJobs, request);
        }
 
        template<typename ListImportJobsRequestT = Model::ListImportJobsRequest>
        void ListImportJobsAsync(const ListImportJobsRequestT& request, const ListImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListImportJobs, request, handler, context);
        }
 
        virtual Model::ListKnowledgeBasesOutcome ListKnowledgeBases(const Model::ListKnowledgeBasesRequest& request = {}) const;
 
        template<typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
        Model::ListKnowledgeBasesOutcomeCallable ListKnowledgeBasesCallable(const ListKnowledgeBasesRequestT& request = {}) const
        {
            return SubmitCallable(&QConnectClient::ListKnowledgeBases, request);
        }
 
        template<typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
        void ListKnowledgeBasesAsync(const ListKnowledgeBasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListKnowledgeBasesRequestT& request = {}) const
        {
            return SubmitAsync(&QConnectClient::ListKnowledgeBases, request, handler, context);
        }
 
        virtual Model::ListMessageTemplateVersionsOutcome ListMessageTemplateVersions(const Model::ListMessageTemplateVersionsRequest& request) const;
 
        template<typename ListMessageTemplateVersionsRequestT = Model::ListMessageTemplateVersionsRequest>
        Model::ListMessageTemplateVersionsOutcomeCallable ListMessageTemplateVersionsCallable(const ListMessageTemplateVersionsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListMessageTemplateVersions, request);
        }
 
        template<typename ListMessageTemplateVersionsRequestT = Model::ListMessageTemplateVersionsRequest>
        void ListMessageTemplateVersionsAsync(const ListMessageTemplateVersionsRequestT& request, const ListMessageTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListMessageTemplateVersions, request, handler, context);
        }
 
        virtual Model::ListMessageTemplatesOutcome ListMessageTemplates(const Model::ListMessageTemplatesRequest& request) const;
 
        template<typename ListMessageTemplatesRequestT = Model::ListMessageTemplatesRequest>
        Model::ListMessageTemplatesOutcomeCallable ListMessageTemplatesCallable(const ListMessageTemplatesRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListMessageTemplates, request);
        }
 
        template<typename ListMessageTemplatesRequestT = Model::ListMessageTemplatesRequest>
        void ListMessageTemplatesAsync(const ListMessageTemplatesRequestT& request, const ListMessageTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListMessageTemplates, request, handler, context);
        }
 
        virtual Model::ListMessagesOutcome ListMessages(const Model::ListMessagesRequest& request) const;
 
        template<typename ListMessagesRequestT = Model::ListMessagesRequest>
        Model::ListMessagesOutcomeCallable ListMessagesCallable(const ListMessagesRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListMessages, request);
        }
 
        template<typename ListMessagesRequestT = Model::ListMessagesRequest>
        void ListMessagesAsync(const ListMessagesRequestT& request, const ListMessagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListMessages, request, handler, context);
        }
 
        virtual Model::ListQuickResponsesOutcome ListQuickResponses(const Model::ListQuickResponsesRequest& request) const;
 
        template<typename ListQuickResponsesRequestT = Model::ListQuickResponsesRequest>
        Model::ListQuickResponsesOutcomeCallable ListQuickResponsesCallable(const ListQuickResponsesRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::ListQuickResponses, request);
        }
 
        template<typename ListQuickResponsesRequestT = Model::ListQuickResponsesRequest>
        void ListQuickResponsesAsync(const ListQuickResponsesRequestT& request, const ListQuickResponsesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::ListQuickResponses, 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(&QConnectClient::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(&QConnectClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::NotifyRecommendationsReceivedOutcome NotifyRecommendationsReceived(const Model::NotifyRecommendationsReceivedRequest& request) const;
 
        template<typename NotifyRecommendationsReceivedRequestT = Model::NotifyRecommendationsReceivedRequest>
        Model::NotifyRecommendationsReceivedOutcomeCallable NotifyRecommendationsReceivedCallable(const NotifyRecommendationsReceivedRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::NotifyRecommendationsReceived, request);
        }
 
        template<typename NotifyRecommendationsReceivedRequestT = Model::NotifyRecommendationsReceivedRequest>
        void NotifyRecommendationsReceivedAsync(const NotifyRecommendationsReceivedRequestT& request, const NotifyRecommendationsReceivedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::NotifyRecommendationsReceived, request, handler, context);
        }
 
        virtual Model::PutFeedbackOutcome PutFeedback(const Model::PutFeedbackRequest& request) const;
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        Model::PutFeedbackOutcomeCallable PutFeedbackCallable(const PutFeedbackRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::PutFeedback, request);
        }
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        void PutFeedbackAsync(const PutFeedbackRequestT& request, const PutFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::PutFeedback, request, handler, context);
        }
 
        virtual Model::RemoveAssistantAIAgentOutcome RemoveAssistantAIAgent(const Model::RemoveAssistantAIAgentRequest& request) const;
 
        template<typename RemoveAssistantAIAgentRequestT = Model::RemoveAssistantAIAgentRequest>
        Model::RemoveAssistantAIAgentOutcomeCallable RemoveAssistantAIAgentCallable(const RemoveAssistantAIAgentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::RemoveAssistantAIAgent, request);
        }
 
        template<typename RemoveAssistantAIAgentRequestT = Model::RemoveAssistantAIAgentRequest>
        void RemoveAssistantAIAgentAsync(const RemoveAssistantAIAgentRequestT& request, const RemoveAssistantAIAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::RemoveAssistantAIAgent, request, handler, context);
        }
 
        virtual Model::RemoveKnowledgeBaseTemplateUriOutcome RemoveKnowledgeBaseTemplateUri(const Model::RemoveKnowledgeBaseTemplateUriRequest& request) const;
 
        template<typename RemoveKnowledgeBaseTemplateUriRequestT = Model::RemoveKnowledgeBaseTemplateUriRequest>
        Model::RemoveKnowledgeBaseTemplateUriOutcomeCallable RemoveKnowledgeBaseTemplateUriCallable(const RemoveKnowledgeBaseTemplateUriRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::RemoveKnowledgeBaseTemplateUri, request);
        }
 
        template<typename RemoveKnowledgeBaseTemplateUriRequestT = Model::RemoveKnowledgeBaseTemplateUriRequest>
        void RemoveKnowledgeBaseTemplateUriAsync(const RemoveKnowledgeBaseTemplateUriRequestT& request, const RemoveKnowledgeBaseTemplateUriResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::RemoveKnowledgeBaseTemplateUri, request, handler, context);
        }
 
        virtual Model::RenderMessageTemplateOutcome RenderMessageTemplate(const Model::RenderMessageTemplateRequest& request) const;
 
        template<typename RenderMessageTemplateRequestT = Model::RenderMessageTemplateRequest>
        Model::RenderMessageTemplateOutcomeCallable RenderMessageTemplateCallable(const RenderMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::RenderMessageTemplate, request);
        }
 
        template<typename RenderMessageTemplateRequestT = Model::RenderMessageTemplateRequest>
        void RenderMessageTemplateAsync(const RenderMessageTemplateRequestT& request, const RenderMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::RenderMessageTemplate, request, handler, context);
        }
 
        virtual Model::SearchContentOutcome SearchContent(const Model::SearchContentRequest& request) const;
 
        template<typename SearchContentRequestT = Model::SearchContentRequest>
        Model::SearchContentOutcomeCallable SearchContentCallable(const SearchContentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::SearchContent, request);
        }
 
        template<typename SearchContentRequestT = Model::SearchContentRequest>
        void SearchContentAsync(const SearchContentRequestT& request, const SearchContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::SearchContent, request, handler, context);
        }
 
        virtual Model::SearchMessageTemplatesOutcome SearchMessageTemplates(const Model::SearchMessageTemplatesRequest& request) const;
 
        template<typename SearchMessageTemplatesRequestT = Model::SearchMessageTemplatesRequest>
        Model::SearchMessageTemplatesOutcomeCallable SearchMessageTemplatesCallable(const SearchMessageTemplatesRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::SearchMessageTemplates, request);
        }
 
        template<typename SearchMessageTemplatesRequestT = Model::SearchMessageTemplatesRequest>
        void SearchMessageTemplatesAsync(const SearchMessageTemplatesRequestT& request, const SearchMessageTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::SearchMessageTemplates, request, handler, context);
        }
 
        virtual Model::SearchQuickResponsesOutcome SearchQuickResponses(const Model::SearchQuickResponsesRequest& request) const;
 
        template<typename SearchQuickResponsesRequestT = Model::SearchQuickResponsesRequest>
        Model::SearchQuickResponsesOutcomeCallable SearchQuickResponsesCallable(const SearchQuickResponsesRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::SearchQuickResponses, request);
        }
 
        template<typename SearchQuickResponsesRequestT = Model::SearchQuickResponsesRequest>
        void SearchQuickResponsesAsync(const SearchQuickResponsesRequestT& request, const SearchQuickResponsesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::SearchQuickResponses, request, handler, context);
        }
 
        virtual Model::SearchSessionsOutcome SearchSessions(const Model::SearchSessionsRequest& request) const;
 
        template<typename SearchSessionsRequestT = Model::SearchSessionsRequest>
        Model::SearchSessionsOutcomeCallable SearchSessionsCallable(const SearchSessionsRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::SearchSessions, request);
        }
 
        template<typename SearchSessionsRequestT = Model::SearchSessionsRequest>
        void SearchSessionsAsync(const SearchSessionsRequestT& request, const SearchSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::SearchSessions, 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(&QConnectClient::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(&QConnectClient::SendMessage, request, handler, context);
        }
 
        virtual Model::StartContentUploadOutcome StartContentUpload(const Model::StartContentUploadRequest& request) const;
 
        template<typename StartContentUploadRequestT = Model::StartContentUploadRequest>
        Model::StartContentUploadOutcomeCallable StartContentUploadCallable(const StartContentUploadRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::StartContentUpload, request);
        }
 
        template<typename StartContentUploadRequestT = Model::StartContentUploadRequest>
        void StartContentUploadAsync(const StartContentUploadRequestT& request, const StartContentUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::StartContentUpload, request, handler, context);
        }
 
        virtual Model::StartImportJobOutcome StartImportJob(const Model::StartImportJobRequest& request) const;
 
        template<typename StartImportJobRequestT = Model::StartImportJobRequest>
        Model::StartImportJobOutcomeCallable StartImportJobCallable(const StartImportJobRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::StartImportJob, request);
        }
 
        template<typename StartImportJobRequestT = Model::StartImportJobRequest>
        void StartImportJobAsync(const StartImportJobRequestT& request, const StartImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::StartImportJob, 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(&QConnectClient::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(&QConnectClient::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(&QConnectClient::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(&QConnectClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAIAgentOutcome UpdateAIAgent(const Model::UpdateAIAgentRequest& request) const;
 
        template<typename UpdateAIAgentRequestT = Model::UpdateAIAgentRequest>
        Model::UpdateAIAgentOutcomeCallable UpdateAIAgentCallable(const UpdateAIAgentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateAIAgent, request);
        }
 
        template<typename UpdateAIAgentRequestT = Model::UpdateAIAgentRequest>
        void UpdateAIAgentAsync(const UpdateAIAgentRequestT& request, const UpdateAIAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateAIAgent, request, handler, context);
        }
 
        virtual Model::UpdateAIGuardrailOutcome UpdateAIGuardrail(const Model::UpdateAIGuardrailRequest& request) const;
 
        template<typename UpdateAIGuardrailRequestT = Model::UpdateAIGuardrailRequest>
        Model::UpdateAIGuardrailOutcomeCallable UpdateAIGuardrailCallable(const UpdateAIGuardrailRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateAIGuardrail, request);
        }
 
        template<typename UpdateAIGuardrailRequestT = Model::UpdateAIGuardrailRequest>
        void UpdateAIGuardrailAsync(const UpdateAIGuardrailRequestT& request, const UpdateAIGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateAIGuardrail, request, handler, context);
        }
 
        virtual Model::UpdateAIPromptOutcome UpdateAIPrompt(const Model::UpdateAIPromptRequest& request) const;
 
        template<typename UpdateAIPromptRequestT = Model::UpdateAIPromptRequest>
        Model::UpdateAIPromptOutcomeCallable UpdateAIPromptCallable(const UpdateAIPromptRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateAIPrompt, request);
        }
 
        template<typename UpdateAIPromptRequestT = Model::UpdateAIPromptRequest>
        void UpdateAIPromptAsync(const UpdateAIPromptRequestT& request, const UpdateAIPromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateAIPrompt, request, handler, context);
        }
 
        virtual Model::UpdateAssistantAIAgentOutcome UpdateAssistantAIAgent(const Model::UpdateAssistantAIAgentRequest& request) const;
 
        template<typename UpdateAssistantAIAgentRequestT = Model::UpdateAssistantAIAgentRequest>
        Model::UpdateAssistantAIAgentOutcomeCallable UpdateAssistantAIAgentCallable(const UpdateAssistantAIAgentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateAssistantAIAgent, request);
        }
 
        template<typename UpdateAssistantAIAgentRequestT = Model::UpdateAssistantAIAgentRequest>
        void UpdateAssistantAIAgentAsync(const UpdateAssistantAIAgentRequestT& request, const UpdateAssistantAIAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateAssistantAIAgent, request, handler, context);
        }
 
        virtual Model::UpdateContentOutcome UpdateContent(const Model::UpdateContentRequest& request) const;
 
        template<typename UpdateContentRequestT = Model::UpdateContentRequest>
        Model::UpdateContentOutcomeCallable UpdateContentCallable(const UpdateContentRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateContent, request);
        }
 
        template<typename UpdateContentRequestT = Model::UpdateContentRequest>
        void UpdateContentAsync(const UpdateContentRequestT& request, const UpdateContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateContent, request, handler, context);
        }
 
        virtual Model::UpdateKnowledgeBaseTemplateUriOutcome UpdateKnowledgeBaseTemplateUri(const Model::UpdateKnowledgeBaseTemplateUriRequest& request) const;
 
        template<typename UpdateKnowledgeBaseTemplateUriRequestT = Model::UpdateKnowledgeBaseTemplateUriRequest>
        Model::UpdateKnowledgeBaseTemplateUriOutcomeCallable UpdateKnowledgeBaseTemplateUriCallable(const UpdateKnowledgeBaseTemplateUriRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateKnowledgeBaseTemplateUri, request);
        }
 
        template<typename UpdateKnowledgeBaseTemplateUriRequestT = Model::UpdateKnowledgeBaseTemplateUriRequest>
        void UpdateKnowledgeBaseTemplateUriAsync(const UpdateKnowledgeBaseTemplateUriRequestT& request, const UpdateKnowledgeBaseTemplateUriResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateKnowledgeBaseTemplateUri, request, handler, context);
        }
 
        virtual Model::UpdateMessageTemplateOutcome UpdateMessageTemplate(const Model::UpdateMessageTemplateRequest& request) const;
 
        template<typename UpdateMessageTemplateRequestT = Model::UpdateMessageTemplateRequest>
        Model::UpdateMessageTemplateOutcomeCallable UpdateMessageTemplateCallable(const UpdateMessageTemplateRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateMessageTemplate, request);
        }
 
        template<typename UpdateMessageTemplateRequestT = Model::UpdateMessageTemplateRequest>
        void UpdateMessageTemplateAsync(const UpdateMessageTemplateRequestT& request, const UpdateMessageTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateMessageTemplate, request, handler, context);
        }
 
        virtual Model::UpdateMessageTemplateMetadataOutcome UpdateMessageTemplateMetadata(const Model::UpdateMessageTemplateMetadataRequest& request) const;
 
        template<typename UpdateMessageTemplateMetadataRequestT = Model::UpdateMessageTemplateMetadataRequest>
        Model::UpdateMessageTemplateMetadataOutcomeCallable UpdateMessageTemplateMetadataCallable(const UpdateMessageTemplateMetadataRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateMessageTemplateMetadata, request);
        }
 
        template<typename UpdateMessageTemplateMetadataRequestT = Model::UpdateMessageTemplateMetadataRequest>
        void UpdateMessageTemplateMetadataAsync(const UpdateMessageTemplateMetadataRequestT& request, const UpdateMessageTemplateMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateMessageTemplateMetadata, request, handler, context);
        }
 
        virtual Model::UpdateQuickResponseOutcome UpdateQuickResponse(const Model::UpdateQuickResponseRequest& request) const;
 
        template<typename UpdateQuickResponseRequestT = Model::UpdateQuickResponseRequest>
        Model::UpdateQuickResponseOutcomeCallable UpdateQuickResponseCallable(const UpdateQuickResponseRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateQuickResponse, request);
        }
 
        template<typename UpdateQuickResponseRequestT = Model::UpdateQuickResponseRequest>
        void UpdateQuickResponseAsync(const UpdateQuickResponseRequestT& request, const UpdateQuickResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateQuickResponse, request, handler, context);
        }
 
        virtual Model::UpdateSessionOutcome UpdateSession(const Model::UpdateSessionRequest& request) const;
 
        template<typename UpdateSessionRequestT = Model::UpdateSessionRequest>
        Model::UpdateSessionOutcomeCallable UpdateSessionCallable(const UpdateSessionRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateSession, request);
        }
 
        template<typename UpdateSessionRequestT = Model::UpdateSessionRequest>
        void UpdateSessionAsync(const UpdateSessionRequestT& request, const UpdateSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateSession, request, handler, context);
        }
 
        virtual Model::UpdateSessionDataOutcome UpdateSessionData(const Model::UpdateSessionDataRequest& request) const;
 
        template<typename UpdateSessionDataRequestT = Model::UpdateSessionDataRequest>
        Model::UpdateSessionDataOutcomeCallable UpdateSessionDataCallable(const UpdateSessionDataRequestT& request) const
        {
            return SubmitCallable(&QConnectClient::UpdateSessionData, request);
        }
 
        template<typename UpdateSessionDataRequestT = Model::UpdateSessionDataRequest>
        void UpdateSessionDataAsync(const UpdateSessionDataRequestT& request, const UpdateSessionDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QConnectClient::UpdateSessionData, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<QConnectEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<QConnectClient>;
      void init(const QConnectClientConfiguration& clientConfiguration);
 
      QConnectClientConfiguration m_clientConfiguration;
      std::shared_ptr<QConnectEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace QConnect
} // namespace Aws