QConnectClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/qconnect/QConnectPaginationBase.h>
#include <aws/qconnect/QConnectServiceClientModel.h>
#include <aws/qconnect/QConnect_EXPORTS.h>
 
namespace Aws {
namespace QConnect {
class AWS_QCONNECT_API QConnectClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<QConnectClient>,
                                        public QConnectPaginationBase<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::ListSpansOutcome ListSpans(const Model::ListSpansRequest& request) const;
 
  template <typename ListSpansRequestT = Model::ListSpansRequest>
  Model::ListSpansOutcomeCallable ListSpansCallable(const ListSpansRequestT& request) const {
    return SubmitCallable(&QConnectClient::ListSpans, request);
  }
 
  template <typename ListSpansRequestT = Model::ListSpansRequest>
  void ListSpansAsync(const ListSpansRequestT& request, const ListSpansResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QConnectClient::ListSpans, 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::RetrieveOutcome Retrieve(const Model::RetrieveRequest& request) const;
 
  template <typename RetrieveRequestT = Model::RetrieveRequest>
  Model::RetrieveOutcomeCallable RetrieveCallable(const RetrieveRequestT& request) const {
    return SubmitCallable(&QConnectClient::Retrieve, request);
  }
 
  template <typename RetrieveRequestT = Model::RetrieveRequest>
  void RetrieveAsync(const RetrieveRequestT& request, const RetrieveResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QConnectClient::Retrieve, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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