ConnectClient.h

 
#pragma once
#include <aws/connect/Connect_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/connect/ConnectServiceClientModel.h>
 
namespace Aws
{
namespace Connect
{
  class AWS_CONNECT_API ConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ConnectClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ConnectClientConfiguration ClientConfigurationType;
      typedef ConnectEndpointProvider EndpointProviderType;
 
        ConnectClient(const Aws::Connect::ConnectClientConfiguration& clientConfiguration = Aws::Connect::ConnectClientConfiguration(),
                      std::shared_ptr<ConnectEndpointProviderBase> endpointProvider = nullptr);
 
        ConnectClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<ConnectEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Connect::ConnectClientConfiguration& clientConfiguration = Aws::Connect::ConnectClientConfiguration());
 
        ConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<ConnectEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Connect::ConnectClientConfiguration& clientConfiguration = Aws::Connect::ConnectClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ConnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ConnectClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ConnectClient();
 
        virtual Model::ActivateEvaluationFormOutcome ActivateEvaluationForm(const Model::ActivateEvaluationFormRequest& request) const;
 
        template<typename ActivateEvaluationFormRequestT = Model::ActivateEvaluationFormRequest>
        Model::ActivateEvaluationFormOutcomeCallable ActivateEvaluationFormCallable(const ActivateEvaluationFormRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ActivateEvaluationForm, request);
        }
 
        template<typename ActivateEvaluationFormRequestT = Model::ActivateEvaluationFormRequest>
        void ActivateEvaluationFormAsync(const ActivateEvaluationFormRequestT& request, const ActivateEvaluationFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ActivateEvaluationForm, request, handler, context);
        }
 
        virtual Model::AssociateAnalyticsDataSetOutcome AssociateAnalyticsDataSet(const Model::AssociateAnalyticsDataSetRequest& request) const;
 
        template<typename AssociateAnalyticsDataSetRequestT = Model::AssociateAnalyticsDataSetRequest>
        Model::AssociateAnalyticsDataSetOutcomeCallable AssociateAnalyticsDataSetCallable(const AssociateAnalyticsDataSetRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateAnalyticsDataSet, request);
        }
 
        template<typename AssociateAnalyticsDataSetRequestT = Model::AssociateAnalyticsDataSetRequest>
        void AssociateAnalyticsDataSetAsync(const AssociateAnalyticsDataSetRequestT& request, const AssociateAnalyticsDataSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateAnalyticsDataSet, request, handler, context);
        }
 
        virtual Model::AssociateApprovedOriginOutcome AssociateApprovedOrigin(const Model::AssociateApprovedOriginRequest& request) const;
 
        template<typename AssociateApprovedOriginRequestT = Model::AssociateApprovedOriginRequest>
        Model::AssociateApprovedOriginOutcomeCallable AssociateApprovedOriginCallable(const AssociateApprovedOriginRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateApprovedOrigin, request);
        }
 
        template<typename AssociateApprovedOriginRequestT = Model::AssociateApprovedOriginRequest>
        void AssociateApprovedOriginAsync(const AssociateApprovedOriginRequestT& request, const AssociateApprovedOriginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateApprovedOrigin, request, handler, context);
        }
 
        virtual Model::AssociateBotOutcome AssociateBot(const Model::AssociateBotRequest& request) const;
 
        template<typename AssociateBotRequestT = Model::AssociateBotRequest>
        Model::AssociateBotOutcomeCallable AssociateBotCallable(const AssociateBotRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateBot, request);
        }
 
        template<typename AssociateBotRequestT = Model::AssociateBotRequest>
        void AssociateBotAsync(const AssociateBotRequestT& request, const AssociateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateBot, request, handler, context);
        }
 
        virtual Model::AssociateDefaultVocabularyOutcome AssociateDefaultVocabulary(const Model::AssociateDefaultVocabularyRequest& request) const;
 
        template<typename AssociateDefaultVocabularyRequestT = Model::AssociateDefaultVocabularyRequest>
        Model::AssociateDefaultVocabularyOutcomeCallable AssociateDefaultVocabularyCallable(const AssociateDefaultVocabularyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateDefaultVocabulary, request);
        }
 
        template<typename AssociateDefaultVocabularyRequestT = Model::AssociateDefaultVocabularyRequest>
        void AssociateDefaultVocabularyAsync(const AssociateDefaultVocabularyRequestT& request, const AssociateDefaultVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateDefaultVocabulary, request, handler, context);
        }
 
        virtual Model::AssociateFlowOutcome AssociateFlow(const Model::AssociateFlowRequest& request) const;
 
        template<typename AssociateFlowRequestT = Model::AssociateFlowRequest>
        Model::AssociateFlowOutcomeCallable AssociateFlowCallable(const AssociateFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateFlow, request);
        }
 
        template<typename AssociateFlowRequestT = Model::AssociateFlowRequest>
        void AssociateFlowAsync(const AssociateFlowRequestT& request, const AssociateFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateFlow, request, handler, context);
        }
 
        virtual Model::AssociateInstanceStorageConfigOutcome AssociateInstanceStorageConfig(const Model::AssociateInstanceStorageConfigRequest& request) const;
 
        template<typename AssociateInstanceStorageConfigRequestT = Model::AssociateInstanceStorageConfigRequest>
        Model::AssociateInstanceStorageConfigOutcomeCallable AssociateInstanceStorageConfigCallable(const AssociateInstanceStorageConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateInstanceStorageConfig, request);
        }
 
        template<typename AssociateInstanceStorageConfigRequestT = Model::AssociateInstanceStorageConfigRequest>
        void AssociateInstanceStorageConfigAsync(const AssociateInstanceStorageConfigRequestT& request, const AssociateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateInstanceStorageConfig, request, handler, context);
        }
 
        virtual Model::AssociateLambdaFunctionOutcome AssociateLambdaFunction(const Model::AssociateLambdaFunctionRequest& request) const;
 
        template<typename AssociateLambdaFunctionRequestT = Model::AssociateLambdaFunctionRequest>
        Model::AssociateLambdaFunctionOutcomeCallable AssociateLambdaFunctionCallable(const AssociateLambdaFunctionRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateLambdaFunction, request);
        }
 
        template<typename AssociateLambdaFunctionRequestT = Model::AssociateLambdaFunctionRequest>
        void AssociateLambdaFunctionAsync(const AssociateLambdaFunctionRequestT& request, const AssociateLambdaFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateLambdaFunction, request, handler, context);
        }
 
        virtual Model::AssociateLexBotOutcome AssociateLexBot(const Model::AssociateLexBotRequest& request) const;
 
        template<typename AssociateLexBotRequestT = Model::AssociateLexBotRequest>
        Model::AssociateLexBotOutcomeCallable AssociateLexBotCallable(const AssociateLexBotRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateLexBot, request);
        }
 
        template<typename AssociateLexBotRequestT = Model::AssociateLexBotRequest>
        void AssociateLexBotAsync(const AssociateLexBotRequestT& request, const AssociateLexBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateLexBot, request, handler, context);
        }
 
        virtual Model::AssociatePhoneNumberContactFlowOutcome AssociatePhoneNumberContactFlow(const Model::AssociatePhoneNumberContactFlowRequest& request) const;
 
        template<typename AssociatePhoneNumberContactFlowRequestT = Model::AssociatePhoneNumberContactFlowRequest>
        Model::AssociatePhoneNumberContactFlowOutcomeCallable AssociatePhoneNumberContactFlowCallable(const AssociatePhoneNumberContactFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociatePhoneNumberContactFlow, request);
        }
 
        template<typename AssociatePhoneNumberContactFlowRequestT = Model::AssociatePhoneNumberContactFlowRequest>
        void AssociatePhoneNumberContactFlowAsync(const AssociatePhoneNumberContactFlowRequestT& request, const AssociatePhoneNumberContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociatePhoneNumberContactFlow, request, handler, context);
        }
 
        virtual Model::AssociateQueueQuickConnectsOutcome AssociateQueueQuickConnects(const Model::AssociateQueueQuickConnectsRequest& request) const;
 
        template<typename AssociateQueueQuickConnectsRequestT = Model::AssociateQueueQuickConnectsRequest>
        Model::AssociateQueueQuickConnectsOutcomeCallable AssociateQueueQuickConnectsCallable(const AssociateQueueQuickConnectsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateQueueQuickConnects, request);
        }
 
        template<typename AssociateQueueQuickConnectsRequestT = Model::AssociateQueueQuickConnectsRequest>
        void AssociateQueueQuickConnectsAsync(const AssociateQueueQuickConnectsRequestT& request, const AssociateQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateQueueQuickConnects, request, handler, context);
        }
 
        virtual Model::AssociateRoutingProfileQueuesOutcome AssociateRoutingProfileQueues(const Model::AssociateRoutingProfileQueuesRequest& request) const;
 
        template<typename AssociateRoutingProfileQueuesRequestT = Model::AssociateRoutingProfileQueuesRequest>
        Model::AssociateRoutingProfileQueuesOutcomeCallable AssociateRoutingProfileQueuesCallable(const AssociateRoutingProfileQueuesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateRoutingProfileQueues, request);
        }
 
        template<typename AssociateRoutingProfileQueuesRequestT = Model::AssociateRoutingProfileQueuesRequest>
        void AssociateRoutingProfileQueuesAsync(const AssociateRoutingProfileQueuesRequestT& request, const AssociateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateRoutingProfileQueues, request, handler, context);
        }
 
        virtual Model::AssociateSecurityKeyOutcome AssociateSecurityKey(const Model::AssociateSecurityKeyRequest& request) const;
 
        template<typename AssociateSecurityKeyRequestT = Model::AssociateSecurityKeyRequest>
        Model::AssociateSecurityKeyOutcomeCallable AssociateSecurityKeyCallable(const AssociateSecurityKeyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateSecurityKey, request);
        }
 
        template<typename AssociateSecurityKeyRequestT = Model::AssociateSecurityKeyRequest>
        void AssociateSecurityKeyAsync(const AssociateSecurityKeyRequestT& request, const AssociateSecurityKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateSecurityKey, request, handler, context);
        }
 
        virtual Model::AssociateTrafficDistributionGroupUserOutcome AssociateTrafficDistributionGroupUser(const Model::AssociateTrafficDistributionGroupUserRequest& request) const;
 
        template<typename AssociateTrafficDistributionGroupUserRequestT = Model::AssociateTrafficDistributionGroupUserRequest>
        Model::AssociateTrafficDistributionGroupUserOutcomeCallable AssociateTrafficDistributionGroupUserCallable(const AssociateTrafficDistributionGroupUserRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateTrafficDistributionGroupUser, request);
        }
 
        template<typename AssociateTrafficDistributionGroupUserRequestT = Model::AssociateTrafficDistributionGroupUserRequest>
        void AssociateTrafficDistributionGroupUserAsync(const AssociateTrafficDistributionGroupUserRequestT& request, const AssociateTrafficDistributionGroupUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateTrafficDistributionGroupUser, request, handler, context);
        }
 
        virtual Model::AssociateUserProficienciesOutcome AssociateUserProficiencies(const Model::AssociateUserProficienciesRequest& request) const;
 
        template<typename AssociateUserProficienciesRequestT = Model::AssociateUserProficienciesRequest>
        Model::AssociateUserProficienciesOutcomeCallable AssociateUserProficienciesCallable(const AssociateUserProficienciesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::AssociateUserProficiencies, request);
        }
 
        template<typename AssociateUserProficienciesRequestT = Model::AssociateUserProficienciesRequest>
        void AssociateUserProficienciesAsync(const AssociateUserProficienciesRequestT& request, const AssociateUserProficienciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::AssociateUserProficiencies, request, handler, context);
        }
 
        virtual Model::BatchAssociateAnalyticsDataSetOutcome BatchAssociateAnalyticsDataSet(const Model::BatchAssociateAnalyticsDataSetRequest& request) const;
 
        template<typename BatchAssociateAnalyticsDataSetRequestT = Model::BatchAssociateAnalyticsDataSetRequest>
        Model::BatchAssociateAnalyticsDataSetOutcomeCallable BatchAssociateAnalyticsDataSetCallable(const BatchAssociateAnalyticsDataSetRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::BatchAssociateAnalyticsDataSet, request);
        }
 
        template<typename BatchAssociateAnalyticsDataSetRequestT = Model::BatchAssociateAnalyticsDataSetRequest>
        void BatchAssociateAnalyticsDataSetAsync(const BatchAssociateAnalyticsDataSetRequestT& request, const BatchAssociateAnalyticsDataSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::BatchAssociateAnalyticsDataSet, request, handler, context);
        }
 
        virtual Model::BatchDisassociateAnalyticsDataSetOutcome BatchDisassociateAnalyticsDataSet(const Model::BatchDisassociateAnalyticsDataSetRequest& request) const;
 
        template<typename BatchDisassociateAnalyticsDataSetRequestT = Model::BatchDisassociateAnalyticsDataSetRequest>
        Model::BatchDisassociateAnalyticsDataSetOutcomeCallable BatchDisassociateAnalyticsDataSetCallable(const BatchDisassociateAnalyticsDataSetRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::BatchDisassociateAnalyticsDataSet, request);
        }
 
        template<typename BatchDisassociateAnalyticsDataSetRequestT = Model::BatchDisassociateAnalyticsDataSetRequest>
        void BatchDisassociateAnalyticsDataSetAsync(const BatchDisassociateAnalyticsDataSetRequestT& request, const BatchDisassociateAnalyticsDataSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::BatchDisassociateAnalyticsDataSet, request, handler, context);
        }
 
        virtual Model::BatchGetAttachedFileMetadataOutcome BatchGetAttachedFileMetadata(const Model::BatchGetAttachedFileMetadataRequest& request) const;
 
        template<typename BatchGetAttachedFileMetadataRequestT = Model::BatchGetAttachedFileMetadataRequest>
        Model::BatchGetAttachedFileMetadataOutcomeCallable BatchGetAttachedFileMetadataCallable(const BatchGetAttachedFileMetadataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::BatchGetAttachedFileMetadata, request);
        }
 
        template<typename BatchGetAttachedFileMetadataRequestT = Model::BatchGetAttachedFileMetadataRequest>
        void BatchGetAttachedFileMetadataAsync(const BatchGetAttachedFileMetadataRequestT& request, const BatchGetAttachedFileMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::BatchGetAttachedFileMetadata, request, handler, context);
        }
 
        virtual Model::BatchGetFlowAssociationOutcome BatchGetFlowAssociation(const Model::BatchGetFlowAssociationRequest& request) const;
 
        template<typename BatchGetFlowAssociationRequestT = Model::BatchGetFlowAssociationRequest>
        Model::BatchGetFlowAssociationOutcomeCallable BatchGetFlowAssociationCallable(const BatchGetFlowAssociationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::BatchGetFlowAssociation, request);
        }
 
        template<typename BatchGetFlowAssociationRequestT = Model::BatchGetFlowAssociationRequest>
        void BatchGetFlowAssociationAsync(const BatchGetFlowAssociationRequestT& request, const BatchGetFlowAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::BatchGetFlowAssociation, request, handler, context);
        }
 
        virtual Model::BatchPutContactOutcome BatchPutContact(const Model::BatchPutContactRequest& request) const;
 
        template<typename BatchPutContactRequestT = Model::BatchPutContactRequest>
        Model::BatchPutContactOutcomeCallable BatchPutContactCallable(const BatchPutContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::BatchPutContact, request);
        }
 
        template<typename BatchPutContactRequestT = Model::BatchPutContactRequest>
        void BatchPutContactAsync(const BatchPutContactRequestT& request, const BatchPutContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::BatchPutContact, request, handler, context);
        }
 
        virtual Model::ClaimPhoneNumberOutcome ClaimPhoneNumber(const Model::ClaimPhoneNumberRequest& request) const;
 
        template<typename ClaimPhoneNumberRequestT = Model::ClaimPhoneNumberRequest>
        Model::ClaimPhoneNumberOutcomeCallable ClaimPhoneNumberCallable(const ClaimPhoneNumberRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ClaimPhoneNumber, request);
        }
 
        template<typename ClaimPhoneNumberRequestT = Model::ClaimPhoneNumberRequest>
        void ClaimPhoneNumberAsync(const ClaimPhoneNumberRequestT& request, const ClaimPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ClaimPhoneNumber, request, handler, context);
        }
 
        virtual Model::CompleteAttachedFileUploadOutcome CompleteAttachedFileUpload(const Model::CompleteAttachedFileUploadRequest& request) const;
 
        template<typename CompleteAttachedFileUploadRequestT = Model::CompleteAttachedFileUploadRequest>
        Model::CompleteAttachedFileUploadOutcomeCallable CompleteAttachedFileUploadCallable(const CompleteAttachedFileUploadRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CompleteAttachedFileUpload, request);
        }
 
        template<typename CompleteAttachedFileUploadRequestT = Model::CompleteAttachedFileUploadRequest>
        void CompleteAttachedFileUploadAsync(const CompleteAttachedFileUploadRequestT& request, const CompleteAttachedFileUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CompleteAttachedFileUpload, request, handler, context);
        }
 
        virtual Model::CreateAgentStatusOutcome CreateAgentStatus(const Model::CreateAgentStatusRequest& request) const;
 
        template<typename CreateAgentStatusRequestT = Model::CreateAgentStatusRequest>
        Model::CreateAgentStatusOutcomeCallable CreateAgentStatusCallable(const CreateAgentStatusRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateAgentStatus, request);
        }
 
        template<typename CreateAgentStatusRequestT = Model::CreateAgentStatusRequest>
        void CreateAgentStatusAsync(const CreateAgentStatusRequestT& request, const CreateAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateAgentStatus, request, handler, context);
        }
 
        virtual Model::CreateContactFlowOutcome CreateContactFlow(const Model::CreateContactFlowRequest& request) const;
 
        template<typename CreateContactFlowRequestT = Model::CreateContactFlowRequest>
        Model::CreateContactFlowOutcomeCallable CreateContactFlowCallable(const CreateContactFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateContactFlow, request);
        }
 
        template<typename CreateContactFlowRequestT = Model::CreateContactFlowRequest>
        void CreateContactFlowAsync(const CreateContactFlowRequestT& request, const CreateContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateContactFlow, request, handler, context);
        }
 
        virtual Model::CreateContactFlowModuleOutcome CreateContactFlowModule(const Model::CreateContactFlowModuleRequest& request) const;
 
        template<typename CreateContactFlowModuleRequestT = Model::CreateContactFlowModuleRequest>
        Model::CreateContactFlowModuleOutcomeCallable CreateContactFlowModuleCallable(const CreateContactFlowModuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateContactFlowModule, request);
        }
 
        template<typename CreateContactFlowModuleRequestT = Model::CreateContactFlowModuleRequest>
        void CreateContactFlowModuleAsync(const CreateContactFlowModuleRequestT& request, const CreateContactFlowModuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateContactFlowModule, request, handler, context);
        }
 
        virtual Model::CreateEvaluationFormOutcome CreateEvaluationForm(const Model::CreateEvaluationFormRequest& request) const;
 
        template<typename CreateEvaluationFormRequestT = Model::CreateEvaluationFormRequest>
        Model::CreateEvaluationFormOutcomeCallable CreateEvaluationFormCallable(const CreateEvaluationFormRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateEvaluationForm, request);
        }
 
        template<typename CreateEvaluationFormRequestT = Model::CreateEvaluationFormRequest>
        void CreateEvaluationFormAsync(const CreateEvaluationFormRequestT& request, const CreateEvaluationFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateEvaluationForm, request, handler, context);
        }
 
        virtual Model::CreateHoursOfOperationOutcome CreateHoursOfOperation(const Model::CreateHoursOfOperationRequest& request) const;
 
        template<typename CreateHoursOfOperationRequestT = Model::CreateHoursOfOperationRequest>
        Model::CreateHoursOfOperationOutcomeCallable CreateHoursOfOperationCallable(const CreateHoursOfOperationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateHoursOfOperation, request);
        }
 
        template<typename CreateHoursOfOperationRequestT = Model::CreateHoursOfOperationRequest>
        void CreateHoursOfOperationAsync(const CreateHoursOfOperationRequestT& request, const CreateHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateHoursOfOperation, request, handler, context);
        }
 
        virtual Model::CreateInstanceOutcome CreateInstance(const Model::CreateInstanceRequest& request) const;
 
        template<typename CreateInstanceRequestT = Model::CreateInstanceRequest>
        Model::CreateInstanceOutcomeCallable CreateInstanceCallable(const CreateInstanceRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateInstance, request);
        }
 
        template<typename CreateInstanceRequestT = Model::CreateInstanceRequest>
        void CreateInstanceAsync(const CreateInstanceRequestT& request, const CreateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateInstance, request, handler, context);
        }
 
        virtual Model::CreateIntegrationAssociationOutcome CreateIntegrationAssociation(const Model::CreateIntegrationAssociationRequest& request) const;
 
        template<typename CreateIntegrationAssociationRequestT = Model::CreateIntegrationAssociationRequest>
        Model::CreateIntegrationAssociationOutcomeCallable CreateIntegrationAssociationCallable(const CreateIntegrationAssociationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateIntegrationAssociation, request);
        }
 
        template<typename CreateIntegrationAssociationRequestT = Model::CreateIntegrationAssociationRequest>
        void CreateIntegrationAssociationAsync(const CreateIntegrationAssociationRequestT& request, const CreateIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateIntegrationAssociation, request, handler, context);
        }
 
        virtual Model::CreateParticipantOutcome CreateParticipant(const Model::CreateParticipantRequest& request) const;
 
        template<typename CreateParticipantRequestT = Model::CreateParticipantRequest>
        Model::CreateParticipantOutcomeCallable CreateParticipantCallable(const CreateParticipantRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateParticipant, request);
        }
 
        template<typename CreateParticipantRequestT = Model::CreateParticipantRequest>
        void CreateParticipantAsync(const CreateParticipantRequestT& request, const CreateParticipantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateParticipant, request, handler, context);
        }
 
        virtual Model::CreatePersistentContactAssociationOutcome CreatePersistentContactAssociation(const Model::CreatePersistentContactAssociationRequest& request) const;
 
        template<typename CreatePersistentContactAssociationRequestT = Model::CreatePersistentContactAssociationRequest>
        Model::CreatePersistentContactAssociationOutcomeCallable CreatePersistentContactAssociationCallable(const CreatePersistentContactAssociationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreatePersistentContactAssociation, request);
        }
 
        template<typename CreatePersistentContactAssociationRequestT = Model::CreatePersistentContactAssociationRequest>
        void CreatePersistentContactAssociationAsync(const CreatePersistentContactAssociationRequestT& request, const CreatePersistentContactAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreatePersistentContactAssociation, request, handler, context);
        }
 
        virtual Model::CreatePredefinedAttributeOutcome CreatePredefinedAttribute(const Model::CreatePredefinedAttributeRequest& request) const;
 
        template<typename CreatePredefinedAttributeRequestT = Model::CreatePredefinedAttributeRequest>
        Model::CreatePredefinedAttributeOutcomeCallable CreatePredefinedAttributeCallable(const CreatePredefinedAttributeRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreatePredefinedAttribute, request);
        }
 
        template<typename CreatePredefinedAttributeRequestT = Model::CreatePredefinedAttributeRequest>
        void CreatePredefinedAttributeAsync(const CreatePredefinedAttributeRequestT& request, const CreatePredefinedAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreatePredefinedAttribute, request, handler, context);
        }
 
        virtual Model::CreatePromptOutcome CreatePrompt(const Model::CreatePromptRequest& request) const;
 
        template<typename CreatePromptRequestT = Model::CreatePromptRequest>
        Model::CreatePromptOutcomeCallable CreatePromptCallable(const CreatePromptRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreatePrompt, request);
        }
 
        template<typename CreatePromptRequestT = Model::CreatePromptRequest>
        void CreatePromptAsync(const CreatePromptRequestT& request, const CreatePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreatePrompt, request, handler, context);
        }
 
        virtual Model::CreateQueueOutcome CreateQueue(const Model::CreateQueueRequest& request) const;
 
        template<typename CreateQueueRequestT = Model::CreateQueueRequest>
        Model::CreateQueueOutcomeCallable CreateQueueCallable(const CreateQueueRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateQueue, request);
        }
 
        template<typename CreateQueueRequestT = Model::CreateQueueRequest>
        void CreateQueueAsync(const CreateQueueRequestT& request, const CreateQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateQueue, request, handler, context);
        }
 
        virtual Model::CreateQuickConnectOutcome CreateQuickConnect(const Model::CreateQuickConnectRequest& request) const;
 
        template<typename CreateQuickConnectRequestT = Model::CreateQuickConnectRequest>
        Model::CreateQuickConnectOutcomeCallable CreateQuickConnectCallable(const CreateQuickConnectRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateQuickConnect, request);
        }
 
        template<typename CreateQuickConnectRequestT = Model::CreateQuickConnectRequest>
        void CreateQuickConnectAsync(const CreateQuickConnectRequestT& request, const CreateQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateQuickConnect, request, handler, context);
        }
 
        virtual Model::CreateRoutingProfileOutcome CreateRoutingProfile(const Model::CreateRoutingProfileRequest& request) const;
 
        template<typename CreateRoutingProfileRequestT = Model::CreateRoutingProfileRequest>
        Model::CreateRoutingProfileOutcomeCallable CreateRoutingProfileCallable(const CreateRoutingProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateRoutingProfile, request);
        }
 
        template<typename CreateRoutingProfileRequestT = Model::CreateRoutingProfileRequest>
        void CreateRoutingProfileAsync(const CreateRoutingProfileRequestT& request, const CreateRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateRoutingProfile, request, handler, context);
        }
 
        virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const;
 
        template<typename CreateRuleRequestT = Model::CreateRuleRequest>
        Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateRule, request);
        }
 
        template<typename CreateRuleRequestT = Model::CreateRuleRequest>
        void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateRule, request, handler, context);
        }
 
        virtual Model::CreateSecurityProfileOutcome CreateSecurityProfile(const Model::CreateSecurityProfileRequest& request) const;
 
        template<typename CreateSecurityProfileRequestT = Model::CreateSecurityProfileRequest>
        Model::CreateSecurityProfileOutcomeCallable CreateSecurityProfileCallable(const CreateSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateSecurityProfile, request);
        }
 
        template<typename CreateSecurityProfileRequestT = Model::CreateSecurityProfileRequest>
        void CreateSecurityProfileAsync(const CreateSecurityProfileRequestT& request, const CreateSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateSecurityProfile, request, handler, context);
        }
 
        virtual Model::CreateTaskTemplateOutcome CreateTaskTemplate(const Model::CreateTaskTemplateRequest& request) const;
 
        template<typename CreateTaskTemplateRequestT = Model::CreateTaskTemplateRequest>
        Model::CreateTaskTemplateOutcomeCallable CreateTaskTemplateCallable(const CreateTaskTemplateRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateTaskTemplate, request);
        }
 
        template<typename CreateTaskTemplateRequestT = Model::CreateTaskTemplateRequest>
        void CreateTaskTemplateAsync(const CreateTaskTemplateRequestT& request, const CreateTaskTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateTaskTemplate, request, handler, context);
        }
 
        virtual Model::CreateTrafficDistributionGroupOutcome CreateTrafficDistributionGroup(const Model::CreateTrafficDistributionGroupRequest& request) const;
 
        template<typename CreateTrafficDistributionGroupRequestT = Model::CreateTrafficDistributionGroupRequest>
        Model::CreateTrafficDistributionGroupOutcomeCallable CreateTrafficDistributionGroupCallable(const CreateTrafficDistributionGroupRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateTrafficDistributionGroup, request);
        }
 
        template<typename CreateTrafficDistributionGroupRequestT = Model::CreateTrafficDistributionGroupRequest>
        void CreateTrafficDistributionGroupAsync(const CreateTrafficDistributionGroupRequestT& request, const CreateTrafficDistributionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateTrafficDistributionGroup, request, handler, context);
        }
 
        virtual Model::CreateUseCaseOutcome CreateUseCase(const Model::CreateUseCaseRequest& request) const;
 
        template<typename CreateUseCaseRequestT = Model::CreateUseCaseRequest>
        Model::CreateUseCaseOutcomeCallable CreateUseCaseCallable(const CreateUseCaseRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateUseCase, request);
        }
 
        template<typename CreateUseCaseRequestT = Model::CreateUseCaseRequest>
        void CreateUseCaseAsync(const CreateUseCaseRequestT& request, const CreateUseCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateUseCase, request, handler, context);
        }
 
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateUser, request);
        }
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateUser, request, handler, context);
        }
 
        virtual Model::CreateUserHierarchyGroupOutcome CreateUserHierarchyGroup(const Model::CreateUserHierarchyGroupRequest& request) const;
 
        template<typename CreateUserHierarchyGroupRequestT = Model::CreateUserHierarchyGroupRequest>
        Model::CreateUserHierarchyGroupOutcomeCallable CreateUserHierarchyGroupCallable(const CreateUserHierarchyGroupRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateUserHierarchyGroup, request);
        }
 
        template<typename CreateUserHierarchyGroupRequestT = Model::CreateUserHierarchyGroupRequest>
        void CreateUserHierarchyGroupAsync(const CreateUserHierarchyGroupRequestT& request, const CreateUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateUserHierarchyGroup, request, handler, context);
        }
 
        virtual Model::CreateViewOutcome CreateView(const Model::CreateViewRequest& request) const;
 
        template<typename CreateViewRequestT = Model::CreateViewRequest>
        Model::CreateViewOutcomeCallable CreateViewCallable(const CreateViewRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateView, request);
        }
 
        template<typename CreateViewRequestT = Model::CreateViewRequest>
        void CreateViewAsync(const CreateViewRequestT& request, const CreateViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateView, request, handler, context);
        }
 
        virtual Model::CreateViewVersionOutcome CreateViewVersion(const Model::CreateViewVersionRequest& request) const;
 
        template<typename CreateViewVersionRequestT = Model::CreateViewVersionRequest>
        Model::CreateViewVersionOutcomeCallable CreateViewVersionCallable(const CreateViewVersionRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateViewVersion, request);
        }
 
        template<typename CreateViewVersionRequestT = Model::CreateViewVersionRequest>
        void CreateViewVersionAsync(const CreateViewVersionRequestT& request, const CreateViewVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateViewVersion, request, handler, context);
        }
 
        virtual Model::CreateVocabularyOutcome CreateVocabulary(const Model::CreateVocabularyRequest& request) const;
 
        template<typename CreateVocabularyRequestT = Model::CreateVocabularyRequest>
        Model::CreateVocabularyOutcomeCallable CreateVocabularyCallable(const CreateVocabularyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::CreateVocabulary, request);
        }
 
        template<typename CreateVocabularyRequestT = Model::CreateVocabularyRequest>
        void CreateVocabularyAsync(const CreateVocabularyRequestT& request, const CreateVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::CreateVocabulary, request, handler, context);
        }
 
        virtual Model::DeactivateEvaluationFormOutcome DeactivateEvaluationForm(const Model::DeactivateEvaluationFormRequest& request) const;
 
        template<typename DeactivateEvaluationFormRequestT = Model::DeactivateEvaluationFormRequest>
        Model::DeactivateEvaluationFormOutcomeCallable DeactivateEvaluationFormCallable(const DeactivateEvaluationFormRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeactivateEvaluationForm, request);
        }
 
        template<typename DeactivateEvaluationFormRequestT = Model::DeactivateEvaluationFormRequest>
        void DeactivateEvaluationFormAsync(const DeactivateEvaluationFormRequestT& request, const DeactivateEvaluationFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeactivateEvaluationForm, request, handler, context);
        }
 
        virtual Model::DeleteAttachedFileOutcome DeleteAttachedFile(const Model::DeleteAttachedFileRequest& request) const;
 
        template<typename DeleteAttachedFileRequestT = Model::DeleteAttachedFileRequest>
        Model::DeleteAttachedFileOutcomeCallable DeleteAttachedFileCallable(const DeleteAttachedFileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteAttachedFile, request);
        }
 
        template<typename DeleteAttachedFileRequestT = Model::DeleteAttachedFileRequest>
        void DeleteAttachedFileAsync(const DeleteAttachedFileRequestT& request, const DeleteAttachedFileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteAttachedFile, request, handler, context);
        }
 
        virtual Model::DeleteContactEvaluationOutcome DeleteContactEvaluation(const Model::DeleteContactEvaluationRequest& request) const;
 
        template<typename DeleteContactEvaluationRequestT = Model::DeleteContactEvaluationRequest>
        Model::DeleteContactEvaluationOutcomeCallable DeleteContactEvaluationCallable(const DeleteContactEvaluationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteContactEvaluation, request);
        }
 
        template<typename DeleteContactEvaluationRequestT = Model::DeleteContactEvaluationRequest>
        void DeleteContactEvaluationAsync(const DeleteContactEvaluationRequestT& request, const DeleteContactEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteContactEvaluation, request, handler, context);
        }
 
        virtual Model::DeleteContactFlowOutcome DeleteContactFlow(const Model::DeleteContactFlowRequest& request) const;
 
        template<typename DeleteContactFlowRequestT = Model::DeleteContactFlowRequest>
        Model::DeleteContactFlowOutcomeCallable DeleteContactFlowCallable(const DeleteContactFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteContactFlow, request);
        }
 
        template<typename DeleteContactFlowRequestT = Model::DeleteContactFlowRequest>
        void DeleteContactFlowAsync(const DeleteContactFlowRequestT& request, const DeleteContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteContactFlow, request, handler, context);
        }
 
        virtual Model::DeleteContactFlowModuleOutcome DeleteContactFlowModule(const Model::DeleteContactFlowModuleRequest& request) const;
 
        template<typename DeleteContactFlowModuleRequestT = Model::DeleteContactFlowModuleRequest>
        Model::DeleteContactFlowModuleOutcomeCallable DeleteContactFlowModuleCallable(const DeleteContactFlowModuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteContactFlowModule, request);
        }
 
        template<typename DeleteContactFlowModuleRequestT = Model::DeleteContactFlowModuleRequest>
        void DeleteContactFlowModuleAsync(const DeleteContactFlowModuleRequestT& request, const DeleteContactFlowModuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteContactFlowModule, request, handler, context);
        }
 
        virtual Model::DeleteEvaluationFormOutcome DeleteEvaluationForm(const Model::DeleteEvaluationFormRequest& request) const;
 
        template<typename DeleteEvaluationFormRequestT = Model::DeleteEvaluationFormRequest>
        Model::DeleteEvaluationFormOutcomeCallable DeleteEvaluationFormCallable(const DeleteEvaluationFormRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteEvaluationForm, request);
        }
 
        template<typename DeleteEvaluationFormRequestT = Model::DeleteEvaluationFormRequest>
        void DeleteEvaluationFormAsync(const DeleteEvaluationFormRequestT& request, const DeleteEvaluationFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteEvaluationForm, request, handler, context);
        }
 
        virtual Model::DeleteHoursOfOperationOutcome DeleteHoursOfOperation(const Model::DeleteHoursOfOperationRequest& request) const;
 
        template<typename DeleteHoursOfOperationRequestT = Model::DeleteHoursOfOperationRequest>
        Model::DeleteHoursOfOperationOutcomeCallable DeleteHoursOfOperationCallable(const DeleteHoursOfOperationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteHoursOfOperation, request);
        }
 
        template<typename DeleteHoursOfOperationRequestT = Model::DeleteHoursOfOperationRequest>
        void DeleteHoursOfOperationAsync(const DeleteHoursOfOperationRequestT& request, const DeleteHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteHoursOfOperation, request, handler, context);
        }
 
        virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const;
 
        template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
        Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteInstance, request);
        }
 
        template<typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
        void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteInstance, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationAssociationOutcome DeleteIntegrationAssociation(const Model::DeleteIntegrationAssociationRequest& request) const;
 
        template<typename DeleteIntegrationAssociationRequestT = Model::DeleteIntegrationAssociationRequest>
        Model::DeleteIntegrationAssociationOutcomeCallable DeleteIntegrationAssociationCallable(const DeleteIntegrationAssociationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteIntegrationAssociation, request);
        }
 
        template<typename DeleteIntegrationAssociationRequestT = Model::DeleteIntegrationAssociationRequest>
        void DeleteIntegrationAssociationAsync(const DeleteIntegrationAssociationRequestT& request, const DeleteIntegrationAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteIntegrationAssociation, request, handler, context);
        }
 
        virtual Model::DeletePredefinedAttributeOutcome DeletePredefinedAttribute(const Model::DeletePredefinedAttributeRequest& request) const;
 
        template<typename DeletePredefinedAttributeRequestT = Model::DeletePredefinedAttributeRequest>
        Model::DeletePredefinedAttributeOutcomeCallable DeletePredefinedAttributeCallable(const DeletePredefinedAttributeRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeletePredefinedAttribute, request);
        }
 
        template<typename DeletePredefinedAttributeRequestT = Model::DeletePredefinedAttributeRequest>
        void DeletePredefinedAttributeAsync(const DeletePredefinedAttributeRequestT& request, const DeletePredefinedAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeletePredefinedAttribute, request, handler, context);
        }
 
        virtual Model::DeletePromptOutcome DeletePrompt(const Model::DeletePromptRequest& request) const;
 
        template<typename DeletePromptRequestT = Model::DeletePromptRequest>
        Model::DeletePromptOutcomeCallable DeletePromptCallable(const DeletePromptRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeletePrompt, request);
        }
 
        template<typename DeletePromptRequestT = Model::DeletePromptRequest>
        void DeletePromptAsync(const DeletePromptRequestT& request, const DeletePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeletePrompt, request, handler, context);
        }
 
        virtual Model::DeleteQueueOutcome DeleteQueue(const Model::DeleteQueueRequest& request) const;
 
        template<typename DeleteQueueRequestT = Model::DeleteQueueRequest>
        Model::DeleteQueueOutcomeCallable DeleteQueueCallable(const DeleteQueueRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteQueue, request);
        }
 
        template<typename DeleteQueueRequestT = Model::DeleteQueueRequest>
        void DeleteQueueAsync(const DeleteQueueRequestT& request, const DeleteQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteQueue, request, handler, context);
        }
 
        virtual Model::DeleteQuickConnectOutcome DeleteQuickConnect(const Model::DeleteQuickConnectRequest& request) const;
 
        template<typename DeleteQuickConnectRequestT = Model::DeleteQuickConnectRequest>
        Model::DeleteQuickConnectOutcomeCallable DeleteQuickConnectCallable(const DeleteQuickConnectRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteQuickConnect, request);
        }
 
        template<typename DeleteQuickConnectRequestT = Model::DeleteQuickConnectRequest>
        void DeleteQuickConnectAsync(const DeleteQuickConnectRequestT& request, const DeleteQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteQuickConnect, request, handler, context);
        }
 
        virtual Model::DeleteRoutingProfileOutcome DeleteRoutingProfile(const Model::DeleteRoutingProfileRequest& request) const;
 
        template<typename DeleteRoutingProfileRequestT = Model::DeleteRoutingProfileRequest>
        Model::DeleteRoutingProfileOutcomeCallable DeleteRoutingProfileCallable(const DeleteRoutingProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteRoutingProfile, request);
        }
 
        template<typename DeleteRoutingProfileRequestT = Model::DeleteRoutingProfileRequest>
        void DeleteRoutingProfileAsync(const DeleteRoutingProfileRequestT& request, const DeleteRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteRoutingProfile, request, handler, context);
        }
 
        virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const;
 
        template<typename DeleteRuleRequestT = Model::DeleteRuleRequest>
        Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteRule, request);
        }
 
        template<typename DeleteRuleRequestT = Model::DeleteRuleRequest>
        void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteRule, request, handler, context);
        }
 
        virtual Model::DeleteSecurityProfileOutcome DeleteSecurityProfile(const Model::DeleteSecurityProfileRequest& request) const;
 
        template<typename DeleteSecurityProfileRequestT = Model::DeleteSecurityProfileRequest>
        Model::DeleteSecurityProfileOutcomeCallable DeleteSecurityProfileCallable(const DeleteSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteSecurityProfile, request);
        }
 
        template<typename DeleteSecurityProfileRequestT = Model::DeleteSecurityProfileRequest>
        void DeleteSecurityProfileAsync(const DeleteSecurityProfileRequestT& request, const DeleteSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteSecurityProfile, request, handler, context);
        }
 
        virtual Model::DeleteTaskTemplateOutcome DeleteTaskTemplate(const Model::DeleteTaskTemplateRequest& request) const;
 
        template<typename DeleteTaskTemplateRequestT = Model::DeleteTaskTemplateRequest>
        Model::DeleteTaskTemplateOutcomeCallable DeleteTaskTemplateCallable(const DeleteTaskTemplateRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteTaskTemplate, request);
        }
 
        template<typename DeleteTaskTemplateRequestT = Model::DeleteTaskTemplateRequest>
        void DeleteTaskTemplateAsync(const DeleteTaskTemplateRequestT& request, const DeleteTaskTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteTaskTemplate, request, handler, context);
        }
 
        virtual Model::DeleteTrafficDistributionGroupOutcome DeleteTrafficDistributionGroup(const Model::DeleteTrafficDistributionGroupRequest& request) const;
 
        template<typename DeleteTrafficDistributionGroupRequestT = Model::DeleteTrafficDistributionGroupRequest>
        Model::DeleteTrafficDistributionGroupOutcomeCallable DeleteTrafficDistributionGroupCallable(const DeleteTrafficDistributionGroupRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteTrafficDistributionGroup, request);
        }
 
        template<typename DeleteTrafficDistributionGroupRequestT = Model::DeleteTrafficDistributionGroupRequest>
        void DeleteTrafficDistributionGroupAsync(const DeleteTrafficDistributionGroupRequestT& request, const DeleteTrafficDistributionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteTrafficDistributionGroup, request, handler, context);
        }
 
        virtual Model::DeleteUseCaseOutcome DeleteUseCase(const Model::DeleteUseCaseRequest& request) const;
 
        template<typename DeleteUseCaseRequestT = Model::DeleteUseCaseRequest>
        Model::DeleteUseCaseOutcomeCallable DeleteUseCaseCallable(const DeleteUseCaseRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteUseCase, request);
        }
 
        template<typename DeleteUseCaseRequestT = Model::DeleteUseCaseRequest>
        void DeleteUseCaseAsync(const DeleteUseCaseRequestT& request, const DeleteUseCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteUseCase, request, handler, context);
        }
 
        virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteUser, request);
        }
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteUser, request, handler, context);
        }
 
        virtual Model::DeleteUserHierarchyGroupOutcome DeleteUserHierarchyGroup(const Model::DeleteUserHierarchyGroupRequest& request) const;
 
        template<typename DeleteUserHierarchyGroupRequestT = Model::DeleteUserHierarchyGroupRequest>
        Model::DeleteUserHierarchyGroupOutcomeCallable DeleteUserHierarchyGroupCallable(const DeleteUserHierarchyGroupRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteUserHierarchyGroup, request);
        }
 
        template<typename DeleteUserHierarchyGroupRequestT = Model::DeleteUserHierarchyGroupRequest>
        void DeleteUserHierarchyGroupAsync(const DeleteUserHierarchyGroupRequestT& request, const DeleteUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteUserHierarchyGroup, request, handler, context);
        }
 
        virtual Model::DeleteViewOutcome DeleteView(const Model::DeleteViewRequest& request) const;
 
        template<typename DeleteViewRequestT = Model::DeleteViewRequest>
        Model::DeleteViewOutcomeCallable DeleteViewCallable(const DeleteViewRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteView, request);
        }
 
        template<typename DeleteViewRequestT = Model::DeleteViewRequest>
        void DeleteViewAsync(const DeleteViewRequestT& request, const DeleteViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteView, request, handler, context);
        }
 
        virtual Model::DeleteViewVersionOutcome DeleteViewVersion(const Model::DeleteViewVersionRequest& request) const;
 
        template<typename DeleteViewVersionRequestT = Model::DeleteViewVersionRequest>
        Model::DeleteViewVersionOutcomeCallable DeleteViewVersionCallable(const DeleteViewVersionRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteViewVersion, request);
        }
 
        template<typename DeleteViewVersionRequestT = Model::DeleteViewVersionRequest>
        void DeleteViewVersionAsync(const DeleteViewVersionRequestT& request, const DeleteViewVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteViewVersion, request, handler, context);
        }
 
        virtual Model::DeleteVocabularyOutcome DeleteVocabulary(const Model::DeleteVocabularyRequest& request) const;
 
        template<typename DeleteVocabularyRequestT = Model::DeleteVocabularyRequest>
        Model::DeleteVocabularyOutcomeCallable DeleteVocabularyCallable(const DeleteVocabularyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DeleteVocabulary, request);
        }
 
        template<typename DeleteVocabularyRequestT = Model::DeleteVocabularyRequest>
        void DeleteVocabularyAsync(const DeleteVocabularyRequestT& request, const DeleteVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DeleteVocabulary, request, handler, context);
        }
 
        virtual Model::DescribeAgentStatusOutcome DescribeAgentStatus(const Model::DescribeAgentStatusRequest& request) const;
 
        template<typename DescribeAgentStatusRequestT = Model::DescribeAgentStatusRequest>
        Model::DescribeAgentStatusOutcomeCallable DescribeAgentStatusCallable(const DescribeAgentStatusRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeAgentStatus, request);
        }
 
        template<typename DescribeAgentStatusRequestT = Model::DescribeAgentStatusRequest>
        void DescribeAgentStatusAsync(const DescribeAgentStatusRequestT& request, const DescribeAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeAgentStatus, request, handler, context);
        }
 
        virtual Model::DescribeAuthenticationProfileOutcome DescribeAuthenticationProfile(const Model::DescribeAuthenticationProfileRequest& request) const;
 
        template<typename DescribeAuthenticationProfileRequestT = Model::DescribeAuthenticationProfileRequest>
        Model::DescribeAuthenticationProfileOutcomeCallable DescribeAuthenticationProfileCallable(const DescribeAuthenticationProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeAuthenticationProfile, request);
        }
 
        template<typename DescribeAuthenticationProfileRequestT = Model::DescribeAuthenticationProfileRequest>
        void DescribeAuthenticationProfileAsync(const DescribeAuthenticationProfileRequestT& request, const DescribeAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeAuthenticationProfile, request, handler, context);
        }
 
        virtual Model::DescribeContactOutcome DescribeContact(const Model::DescribeContactRequest& request) const;
 
        template<typename DescribeContactRequestT = Model::DescribeContactRequest>
        Model::DescribeContactOutcomeCallable DescribeContactCallable(const DescribeContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeContact, request);
        }
 
        template<typename DescribeContactRequestT = Model::DescribeContactRequest>
        void DescribeContactAsync(const DescribeContactRequestT& request, const DescribeContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeContact, request, handler, context);
        }
 
        virtual Model::DescribeContactEvaluationOutcome DescribeContactEvaluation(const Model::DescribeContactEvaluationRequest& request) const;
 
        template<typename DescribeContactEvaluationRequestT = Model::DescribeContactEvaluationRequest>
        Model::DescribeContactEvaluationOutcomeCallable DescribeContactEvaluationCallable(const DescribeContactEvaluationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeContactEvaluation, request);
        }
 
        template<typename DescribeContactEvaluationRequestT = Model::DescribeContactEvaluationRequest>
        void DescribeContactEvaluationAsync(const DescribeContactEvaluationRequestT& request, const DescribeContactEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeContactEvaluation, request, handler, context);
        }
 
        virtual Model::DescribeContactFlowOutcome DescribeContactFlow(const Model::DescribeContactFlowRequest& request) const;
 
        template<typename DescribeContactFlowRequestT = Model::DescribeContactFlowRequest>
        Model::DescribeContactFlowOutcomeCallable DescribeContactFlowCallable(const DescribeContactFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeContactFlow, request);
        }
 
        template<typename DescribeContactFlowRequestT = Model::DescribeContactFlowRequest>
        void DescribeContactFlowAsync(const DescribeContactFlowRequestT& request, const DescribeContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeContactFlow, request, handler, context);
        }
 
        virtual Model::DescribeContactFlowModuleOutcome DescribeContactFlowModule(const Model::DescribeContactFlowModuleRequest& request) const;
 
        template<typename DescribeContactFlowModuleRequestT = Model::DescribeContactFlowModuleRequest>
        Model::DescribeContactFlowModuleOutcomeCallable DescribeContactFlowModuleCallable(const DescribeContactFlowModuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeContactFlowModule, request);
        }
 
        template<typename DescribeContactFlowModuleRequestT = Model::DescribeContactFlowModuleRequest>
        void DescribeContactFlowModuleAsync(const DescribeContactFlowModuleRequestT& request, const DescribeContactFlowModuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeContactFlowModule, request, handler, context);
        }
 
        virtual Model::DescribeEvaluationFormOutcome DescribeEvaluationForm(const Model::DescribeEvaluationFormRequest& request) const;
 
        template<typename DescribeEvaluationFormRequestT = Model::DescribeEvaluationFormRequest>
        Model::DescribeEvaluationFormOutcomeCallable DescribeEvaluationFormCallable(const DescribeEvaluationFormRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeEvaluationForm, request);
        }
 
        template<typename DescribeEvaluationFormRequestT = Model::DescribeEvaluationFormRequest>
        void DescribeEvaluationFormAsync(const DescribeEvaluationFormRequestT& request, const DescribeEvaluationFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeEvaluationForm, request, handler, context);
        }
 
        virtual Model::DescribeHoursOfOperationOutcome DescribeHoursOfOperation(const Model::DescribeHoursOfOperationRequest& request) const;
 
        template<typename DescribeHoursOfOperationRequestT = Model::DescribeHoursOfOperationRequest>
        Model::DescribeHoursOfOperationOutcomeCallable DescribeHoursOfOperationCallable(const DescribeHoursOfOperationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeHoursOfOperation, request);
        }
 
        template<typename DescribeHoursOfOperationRequestT = Model::DescribeHoursOfOperationRequest>
        void DescribeHoursOfOperationAsync(const DescribeHoursOfOperationRequestT& request, const DescribeHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeHoursOfOperation, request, handler, context);
        }
 
        virtual Model::DescribeInstanceOutcome DescribeInstance(const Model::DescribeInstanceRequest& request) const;
 
        template<typename DescribeInstanceRequestT = Model::DescribeInstanceRequest>
        Model::DescribeInstanceOutcomeCallable DescribeInstanceCallable(const DescribeInstanceRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeInstance, request);
        }
 
        template<typename DescribeInstanceRequestT = Model::DescribeInstanceRequest>
        void DescribeInstanceAsync(const DescribeInstanceRequestT& request, const DescribeInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeInstance, request, handler, context);
        }
 
        virtual Model::DescribeInstanceAttributeOutcome DescribeInstanceAttribute(const Model::DescribeInstanceAttributeRequest& request) const;
 
        template<typename DescribeInstanceAttributeRequestT = Model::DescribeInstanceAttributeRequest>
        Model::DescribeInstanceAttributeOutcomeCallable DescribeInstanceAttributeCallable(const DescribeInstanceAttributeRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeInstanceAttribute, request);
        }
 
        template<typename DescribeInstanceAttributeRequestT = Model::DescribeInstanceAttributeRequest>
        void DescribeInstanceAttributeAsync(const DescribeInstanceAttributeRequestT& request, const DescribeInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeInstanceAttribute, request, handler, context);
        }
 
        virtual Model::DescribeInstanceStorageConfigOutcome DescribeInstanceStorageConfig(const Model::DescribeInstanceStorageConfigRequest& request) const;
 
        template<typename DescribeInstanceStorageConfigRequestT = Model::DescribeInstanceStorageConfigRequest>
        Model::DescribeInstanceStorageConfigOutcomeCallable DescribeInstanceStorageConfigCallable(const DescribeInstanceStorageConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeInstanceStorageConfig, request);
        }
 
        template<typename DescribeInstanceStorageConfigRequestT = Model::DescribeInstanceStorageConfigRequest>
        void DescribeInstanceStorageConfigAsync(const DescribeInstanceStorageConfigRequestT& request, const DescribeInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeInstanceStorageConfig, request, handler, context);
        }
 
        virtual Model::DescribePhoneNumberOutcome DescribePhoneNumber(const Model::DescribePhoneNumberRequest& request) const;
 
        template<typename DescribePhoneNumberRequestT = Model::DescribePhoneNumberRequest>
        Model::DescribePhoneNumberOutcomeCallable DescribePhoneNumberCallable(const DescribePhoneNumberRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribePhoneNumber, request);
        }
 
        template<typename DescribePhoneNumberRequestT = Model::DescribePhoneNumberRequest>
        void DescribePhoneNumberAsync(const DescribePhoneNumberRequestT& request, const DescribePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribePhoneNumber, request, handler, context);
        }
 
        virtual Model::DescribePredefinedAttributeOutcome DescribePredefinedAttribute(const Model::DescribePredefinedAttributeRequest& request) const;
 
        template<typename DescribePredefinedAttributeRequestT = Model::DescribePredefinedAttributeRequest>
        Model::DescribePredefinedAttributeOutcomeCallable DescribePredefinedAttributeCallable(const DescribePredefinedAttributeRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribePredefinedAttribute, request);
        }
 
        template<typename DescribePredefinedAttributeRequestT = Model::DescribePredefinedAttributeRequest>
        void DescribePredefinedAttributeAsync(const DescribePredefinedAttributeRequestT& request, const DescribePredefinedAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribePredefinedAttribute, request, handler, context);
        }
 
        virtual Model::DescribePromptOutcome DescribePrompt(const Model::DescribePromptRequest& request) const;
 
        template<typename DescribePromptRequestT = Model::DescribePromptRequest>
        Model::DescribePromptOutcomeCallable DescribePromptCallable(const DescribePromptRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribePrompt, request);
        }
 
        template<typename DescribePromptRequestT = Model::DescribePromptRequest>
        void DescribePromptAsync(const DescribePromptRequestT& request, const DescribePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribePrompt, request, handler, context);
        }
 
        virtual Model::DescribeQueueOutcome DescribeQueue(const Model::DescribeQueueRequest& request) const;
 
        template<typename DescribeQueueRequestT = Model::DescribeQueueRequest>
        Model::DescribeQueueOutcomeCallable DescribeQueueCallable(const DescribeQueueRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeQueue, request);
        }
 
        template<typename DescribeQueueRequestT = Model::DescribeQueueRequest>
        void DescribeQueueAsync(const DescribeQueueRequestT& request, const DescribeQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeQueue, request, handler, context);
        }
 
        virtual Model::DescribeQuickConnectOutcome DescribeQuickConnect(const Model::DescribeQuickConnectRequest& request) const;
 
        template<typename DescribeQuickConnectRequestT = Model::DescribeQuickConnectRequest>
        Model::DescribeQuickConnectOutcomeCallable DescribeQuickConnectCallable(const DescribeQuickConnectRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeQuickConnect, request);
        }
 
        template<typename DescribeQuickConnectRequestT = Model::DescribeQuickConnectRequest>
        void DescribeQuickConnectAsync(const DescribeQuickConnectRequestT& request, const DescribeQuickConnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeQuickConnect, request, handler, context);
        }
 
        virtual Model::DescribeRoutingProfileOutcome DescribeRoutingProfile(const Model::DescribeRoutingProfileRequest& request) const;
 
        template<typename DescribeRoutingProfileRequestT = Model::DescribeRoutingProfileRequest>
        Model::DescribeRoutingProfileOutcomeCallable DescribeRoutingProfileCallable(const DescribeRoutingProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeRoutingProfile, request);
        }
 
        template<typename DescribeRoutingProfileRequestT = Model::DescribeRoutingProfileRequest>
        void DescribeRoutingProfileAsync(const DescribeRoutingProfileRequestT& request, const DescribeRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeRoutingProfile, request, handler, context);
        }
 
        virtual Model::DescribeRuleOutcome DescribeRule(const Model::DescribeRuleRequest& request) const;
 
        template<typename DescribeRuleRequestT = Model::DescribeRuleRequest>
        Model::DescribeRuleOutcomeCallable DescribeRuleCallable(const DescribeRuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeRule, request);
        }
 
        template<typename DescribeRuleRequestT = Model::DescribeRuleRequest>
        void DescribeRuleAsync(const DescribeRuleRequestT& request, const DescribeRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeRule, request, handler, context);
        }
 
        virtual Model::DescribeSecurityProfileOutcome DescribeSecurityProfile(const Model::DescribeSecurityProfileRequest& request) const;
 
        template<typename DescribeSecurityProfileRequestT = Model::DescribeSecurityProfileRequest>
        Model::DescribeSecurityProfileOutcomeCallable DescribeSecurityProfileCallable(const DescribeSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeSecurityProfile, request);
        }
 
        template<typename DescribeSecurityProfileRequestT = Model::DescribeSecurityProfileRequest>
        void DescribeSecurityProfileAsync(const DescribeSecurityProfileRequestT& request, const DescribeSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeSecurityProfile, request, handler, context);
        }
 
        virtual Model::DescribeTrafficDistributionGroupOutcome DescribeTrafficDistributionGroup(const Model::DescribeTrafficDistributionGroupRequest& request) const;
 
        template<typename DescribeTrafficDistributionGroupRequestT = Model::DescribeTrafficDistributionGroupRequest>
        Model::DescribeTrafficDistributionGroupOutcomeCallable DescribeTrafficDistributionGroupCallable(const DescribeTrafficDistributionGroupRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeTrafficDistributionGroup, request);
        }
 
        template<typename DescribeTrafficDistributionGroupRequestT = Model::DescribeTrafficDistributionGroupRequest>
        void DescribeTrafficDistributionGroupAsync(const DescribeTrafficDistributionGroupRequestT& request, const DescribeTrafficDistributionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeTrafficDistributionGroup, request, handler, context);
        }
 
        virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;
 
        template<typename DescribeUserRequestT = Model::DescribeUserRequest>
        Model::DescribeUserOutcomeCallable DescribeUserCallable(const DescribeUserRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeUser, request);
        }
 
        template<typename DescribeUserRequestT = Model::DescribeUserRequest>
        void DescribeUserAsync(const DescribeUserRequestT& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeUser, request, handler, context);
        }
 
        virtual Model::DescribeUserHierarchyGroupOutcome DescribeUserHierarchyGroup(const Model::DescribeUserHierarchyGroupRequest& request) const;
 
        template<typename DescribeUserHierarchyGroupRequestT = Model::DescribeUserHierarchyGroupRequest>
        Model::DescribeUserHierarchyGroupOutcomeCallable DescribeUserHierarchyGroupCallable(const DescribeUserHierarchyGroupRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeUserHierarchyGroup, request);
        }
 
        template<typename DescribeUserHierarchyGroupRequestT = Model::DescribeUserHierarchyGroupRequest>
        void DescribeUserHierarchyGroupAsync(const DescribeUserHierarchyGroupRequestT& request, const DescribeUserHierarchyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeUserHierarchyGroup, request, handler, context);
        }
 
        virtual Model::DescribeUserHierarchyStructureOutcome DescribeUserHierarchyStructure(const Model::DescribeUserHierarchyStructureRequest& request) const;
 
        template<typename DescribeUserHierarchyStructureRequestT = Model::DescribeUserHierarchyStructureRequest>
        Model::DescribeUserHierarchyStructureOutcomeCallable DescribeUserHierarchyStructureCallable(const DescribeUserHierarchyStructureRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeUserHierarchyStructure, request);
        }
 
        template<typename DescribeUserHierarchyStructureRequestT = Model::DescribeUserHierarchyStructureRequest>
        void DescribeUserHierarchyStructureAsync(const DescribeUserHierarchyStructureRequestT& request, const DescribeUserHierarchyStructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeUserHierarchyStructure, request, handler, context);
        }
 
        virtual Model::DescribeViewOutcome DescribeView(const Model::DescribeViewRequest& request) const;
 
        template<typename DescribeViewRequestT = Model::DescribeViewRequest>
        Model::DescribeViewOutcomeCallable DescribeViewCallable(const DescribeViewRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeView, request);
        }
 
        template<typename DescribeViewRequestT = Model::DescribeViewRequest>
        void DescribeViewAsync(const DescribeViewRequestT& request, const DescribeViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeView, request, handler, context);
        }
 
        virtual Model::DescribeVocabularyOutcome DescribeVocabulary(const Model::DescribeVocabularyRequest& request) const;
 
        template<typename DescribeVocabularyRequestT = Model::DescribeVocabularyRequest>
        Model::DescribeVocabularyOutcomeCallable DescribeVocabularyCallable(const DescribeVocabularyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DescribeVocabulary, request);
        }
 
        template<typename DescribeVocabularyRequestT = Model::DescribeVocabularyRequest>
        void DescribeVocabularyAsync(const DescribeVocabularyRequestT& request, const DescribeVocabularyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DescribeVocabulary, request, handler, context);
        }
 
        virtual Model::DisassociateAnalyticsDataSetOutcome DisassociateAnalyticsDataSet(const Model::DisassociateAnalyticsDataSetRequest& request) const;
 
        template<typename DisassociateAnalyticsDataSetRequestT = Model::DisassociateAnalyticsDataSetRequest>
        Model::DisassociateAnalyticsDataSetOutcomeCallable DisassociateAnalyticsDataSetCallable(const DisassociateAnalyticsDataSetRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateAnalyticsDataSet, request);
        }
 
        template<typename DisassociateAnalyticsDataSetRequestT = Model::DisassociateAnalyticsDataSetRequest>
        void DisassociateAnalyticsDataSetAsync(const DisassociateAnalyticsDataSetRequestT& request, const DisassociateAnalyticsDataSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateAnalyticsDataSet, request, handler, context);
        }
 
        virtual Model::DisassociateApprovedOriginOutcome DisassociateApprovedOrigin(const Model::DisassociateApprovedOriginRequest& request) const;
 
        template<typename DisassociateApprovedOriginRequestT = Model::DisassociateApprovedOriginRequest>
        Model::DisassociateApprovedOriginOutcomeCallable DisassociateApprovedOriginCallable(const DisassociateApprovedOriginRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateApprovedOrigin, request);
        }
 
        template<typename DisassociateApprovedOriginRequestT = Model::DisassociateApprovedOriginRequest>
        void DisassociateApprovedOriginAsync(const DisassociateApprovedOriginRequestT& request, const DisassociateApprovedOriginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateApprovedOrigin, request, handler, context);
        }
 
        virtual Model::DisassociateBotOutcome DisassociateBot(const Model::DisassociateBotRequest& request) const;
 
        template<typename DisassociateBotRequestT = Model::DisassociateBotRequest>
        Model::DisassociateBotOutcomeCallable DisassociateBotCallable(const DisassociateBotRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateBot, request);
        }
 
        template<typename DisassociateBotRequestT = Model::DisassociateBotRequest>
        void DisassociateBotAsync(const DisassociateBotRequestT& request, const DisassociateBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateBot, request, handler, context);
        }
 
        virtual Model::DisassociateFlowOutcome DisassociateFlow(const Model::DisassociateFlowRequest& request) const;
 
        template<typename DisassociateFlowRequestT = Model::DisassociateFlowRequest>
        Model::DisassociateFlowOutcomeCallable DisassociateFlowCallable(const DisassociateFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateFlow, request);
        }
 
        template<typename DisassociateFlowRequestT = Model::DisassociateFlowRequest>
        void DisassociateFlowAsync(const DisassociateFlowRequestT& request, const DisassociateFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateFlow, request, handler, context);
        }
 
        virtual Model::DisassociateInstanceStorageConfigOutcome DisassociateInstanceStorageConfig(const Model::DisassociateInstanceStorageConfigRequest& request) const;
 
        template<typename DisassociateInstanceStorageConfigRequestT = Model::DisassociateInstanceStorageConfigRequest>
        Model::DisassociateInstanceStorageConfigOutcomeCallable DisassociateInstanceStorageConfigCallable(const DisassociateInstanceStorageConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateInstanceStorageConfig, request);
        }
 
        template<typename DisassociateInstanceStorageConfigRequestT = Model::DisassociateInstanceStorageConfigRequest>
        void DisassociateInstanceStorageConfigAsync(const DisassociateInstanceStorageConfigRequestT& request, const DisassociateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateInstanceStorageConfig, request, handler, context);
        }
 
        virtual Model::DisassociateLambdaFunctionOutcome DisassociateLambdaFunction(const Model::DisassociateLambdaFunctionRequest& request) const;
 
        template<typename DisassociateLambdaFunctionRequestT = Model::DisassociateLambdaFunctionRequest>
        Model::DisassociateLambdaFunctionOutcomeCallable DisassociateLambdaFunctionCallable(const DisassociateLambdaFunctionRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateLambdaFunction, request);
        }
 
        template<typename DisassociateLambdaFunctionRequestT = Model::DisassociateLambdaFunctionRequest>
        void DisassociateLambdaFunctionAsync(const DisassociateLambdaFunctionRequestT& request, const DisassociateLambdaFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateLambdaFunction, request, handler, context);
        }
 
        virtual Model::DisassociateLexBotOutcome DisassociateLexBot(const Model::DisassociateLexBotRequest& request) const;
 
        template<typename DisassociateLexBotRequestT = Model::DisassociateLexBotRequest>
        Model::DisassociateLexBotOutcomeCallable DisassociateLexBotCallable(const DisassociateLexBotRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateLexBot, request);
        }
 
        template<typename DisassociateLexBotRequestT = Model::DisassociateLexBotRequest>
        void DisassociateLexBotAsync(const DisassociateLexBotRequestT& request, const DisassociateLexBotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateLexBot, request, handler, context);
        }
 
        virtual Model::DisassociatePhoneNumberContactFlowOutcome DisassociatePhoneNumberContactFlow(const Model::DisassociatePhoneNumberContactFlowRequest& request) const;
 
        template<typename DisassociatePhoneNumberContactFlowRequestT = Model::DisassociatePhoneNumberContactFlowRequest>
        Model::DisassociatePhoneNumberContactFlowOutcomeCallable DisassociatePhoneNumberContactFlowCallable(const DisassociatePhoneNumberContactFlowRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociatePhoneNumberContactFlow, request);
        }
 
        template<typename DisassociatePhoneNumberContactFlowRequestT = Model::DisassociatePhoneNumberContactFlowRequest>
        void DisassociatePhoneNumberContactFlowAsync(const DisassociatePhoneNumberContactFlowRequestT& request, const DisassociatePhoneNumberContactFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociatePhoneNumberContactFlow, request, handler, context);
        }
 
        virtual Model::DisassociateQueueQuickConnectsOutcome DisassociateQueueQuickConnects(const Model::DisassociateQueueQuickConnectsRequest& request) const;
 
        template<typename DisassociateQueueQuickConnectsRequestT = Model::DisassociateQueueQuickConnectsRequest>
        Model::DisassociateQueueQuickConnectsOutcomeCallable DisassociateQueueQuickConnectsCallable(const DisassociateQueueQuickConnectsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateQueueQuickConnects, request);
        }
 
        template<typename DisassociateQueueQuickConnectsRequestT = Model::DisassociateQueueQuickConnectsRequest>
        void DisassociateQueueQuickConnectsAsync(const DisassociateQueueQuickConnectsRequestT& request, const DisassociateQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateQueueQuickConnects, request, handler, context);
        }
 
        virtual Model::DisassociateRoutingProfileQueuesOutcome DisassociateRoutingProfileQueues(const Model::DisassociateRoutingProfileQueuesRequest& request) const;
 
        template<typename DisassociateRoutingProfileQueuesRequestT = Model::DisassociateRoutingProfileQueuesRequest>
        Model::DisassociateRoutingProfileQueuesOutcomeCallable DisassociateRoutingProfileQueuesCallable(const DisassociateRoutingProfileQueuesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateRoutingProfileQueues, request);
        }
 
        template<typename DisassociateRoutingProfileQueuesRequestT = Model::DisassociateRoutingProfileQueuesRequest>
        void DisassociateRoutingProfileQueuesAsync(const DisassociateRoutingProfileQueuesRequestT& request, const DisassociateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateRoutingProfileQueues, request, handler, context);
        }
 
        virtual Model::DisassociateSecurityKeyOutcome DisassociateSecurityKey(const Model::DisassociateSecurityKeyRequest& request) const;
 
        template<typename DisassociateSecurityKeyRequestT = Model::DisassociateSecurityKeyRequest>
        Model::DisassociateSecurityKeyOutcomeCallable DisassociateSecurityKeyCallable(const DisassociateSecurityKeyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateSecurityKey, request);
        }
 
        template<typename DisassociateSecurityKeyRequestT = Model::DisassociateSecurityKeyRequest>
        void DisassociateSecurityKeyAsync(const DisassociateSecurityKeyRequestT& request, const DisassociateSecurityKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateSecurityKey, request, handler, context);
        }
 
        virtual Model::DisassociateTrafficDistributionGroupUserOutcome DisassociateTrafficDistributionGroupUser(const Model::DisassociateTrafficDistributionGroupUserRequest& request) const;
 
        template<typename DisassociateTrafficDistributionGroupUserRequestT = Model::DisassociateTrafficDistributionGroupUserRequest>
        Model::DisassociateTrafficDistributionGroupUserOutcomeCallable DisassociateTrafficDistributionGroupUserCallable(const DisassociateTrafficDistributionGroupUserRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateTrafficDistributionGroupUser, request);
        }
 
        template<typename DisassociateTrafficDistributionGroupUserRequestT = Model::DisassociateTrafficDistributionGroupUserRequest>
        void DisassociateTrafficDistributionGroupUserAsync(const DisassociateTrafficDistributionGroupUserRequestT& request, const DisassociateTrafficDistributionGroupUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateTrafficDistributionGroupUser, request, handler, context);
        }
 
        virtual Model::DisassociateUserProficienciesOutcome DisassociateUserProficiencies(const Model::DisassociateUserProficienciesRequest& request) const;
 
        template<typename DisassociateUserProficienciesRequestT = Model::DisassociateUserProficienciesRequest>
        Model::DisassociateUserProficienciesOutcomeCallable DisassociateUserProficienciesCallable(const DisassociateUserProficienciesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DisassociateUserProficiencies, request);
        }
 
        template<typename DisassociateUserProficienciesRequestT = Model::DisassociateUserProficienciesRequest>
        void DisassociateUserProficienciesAsync(const DisassociateUserProficienciesRequestT& request, const DisassociateUserProficienciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DisassociateUserProficiencies, request, handler, context);
        }
 
        virtual Model::DismissUserContactOutcome DismissUserContact(const Model::DismissUserContactRequest& request) const;
 
        template<typename DismissUserContactRequestT = Model::DismissUserContactRequest>
        Model::DismissUserContactOutcomeCallable DismissUserContactCallable(const DismissUserContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::DismissUserContact, request);
        }
 
        template<typename DismissUserContactRequestT = Model::DismissUserContactRequest>
        void DismissUserContactAsync(const DismissUserContactRequestT& request, const DismissUserContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::DismissUserContact, request, handler, context);
        }
 
        virtual Model::GetAttachedFileOutcome GetAttachedFile(const Model::GetAttachedFileRequest& request) const;
 
        template<typename GetAttachedFileRequestT = Model::GetAttachedFileRequest>
        Model::GetAttachedFileOutcomeCallable GetAttachedFileCallable(const GetAttachedFileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetAttachedFile, request);
        }
 
        template<typename GetAttachedFileRequestT = Model::GetAttachedFileRequest>
        void GetAttachedFileAsync(const GetAttachedFileRequestT& request, const GetAttachedFileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetAttachedFile, request, handler, context);
        }
 
        virtual Model::GetContactAttributesOutcome GetContactAttributes(const Model::GetContactAttributesRequest& request) const;
 
        template<typename GetContactAttributesRequestT = Model::GetContactAttributesRequest>
        Model::GetContactAttributesOutcomeCallable GetContactAttributesCallable(const GetContactAttributesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetContactAttributes, request);
        }
 
        template<typename GetContactAttributesRequestT = Model::GetContactAttributesRequest>
        void GetContactAttributesAsync(const GetContactAttributesRequestT& request, const GetContactAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetContactAttributes, request, handler, context);
        }
 
        virtual Model::GetCurrentMetricDataOutcome GetCurrentMetricData(const Model::GetCurrentMetricDataRequest& request) const;
 
        template<typename GetCurrentMetricDataRequestT = Model::GetCurrentMetricDataRequest>
        Model::GetCurrentMetricDataOutcomeCallable GetCurrentMetricDataCallable(const GetCurrentMetricDataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetCurrentMetricData, request);
        }
 
        template<typename GetCurrentMetricDataRequestT = Model::GetCurrentMetricDataRequest>
        void GetCurrentMetricDataAsync(const GetCurrentMetricDataRequestT& request, const GetCurrentMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetCurrentMetricData, request, handler, context);
        }
 
        virtual Model::GetCurrentUserDataOutcome GetCurrentUserData(const Model::GetCurrentUserDataRequest& request) const;
 
        template<typename GetCurrentUserDataRequestT = Model::GetCurrentUserDataRequest>
        Model::GetCurrentUserDataOutcomeCallable GetCurrentUserDataCallable(const GetCurrentUserDataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetCurrentUserData, request);
        }
 
        template<typename GetCurrentUserDataRequestT = Model::GetCurrentUserDataRequest>
        void GetCurrentUserDataAsync(const GetCurrentUserDataRequestT& request, const GetCurrentUserDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetCurrentUserData, request, handler, context);
        }
 
        virtual Model::GetFederationTokenOutcome GetFederationToken(const Model::GetFederationTokenRequest& request) const;
 
        template<typename GetFederationTokenRequestT = Model::GetFederationTokenRequest>
        Model::GetFederationTokenOutcomeCallable GetFederationTokenCallable(const GetFederationTokenRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetFederationToken, request);
        }
 
        template<typename GetFederationTokenRequestT = Model::GetFederationTokenRequest>
        void GetFederationTokenAsync(const GetFederationTokenRequestT& request, const GetFederationTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetFederationToken, request, handler, context);
        }
 
        virtual Model::GetFlowAssociationOutcome GetFlowAssociation(const Model::GetFlowAssociationRequest& request) const;
 
        template<typename GetFlowAssociationRequestT = Model::GetFlowAssociationRequest>
        Model::GetFlowAssociationOutcomeCallable GetFlowAssociationCallable(const GetFlowAssociationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetFlowAssociation, request);
        }
 
        template<typename GetFlowAssociationRequestT = Model::GetFlowAssociationRequest>
        void GetFlowAssociationAsync(const GetFlowAssociationRequestT& request, const GetFlowAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetFlowAssociation, request, handler, context);
        }
 
        virtual Model::GetMetricDataOutcome GetMetricData(const Model::GetMetricDataRequest& request) const;
 
        template<typename GetMetricDataRequestT = Model::GetMetricDataRequest>
        Model::GetMetricDataOutcomeCallable GetMetricDataCallable(const GetMetricDataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetMetricData, request);
        }
 
        template<typename GetMetricDataRequestT = Model::GetMetricDataRequest>
        void GetMetricDataAsync(const GetMetricDataRequestT& request, const GetMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetMetricData, request, handler, context);
        }
 
        virtual Model::GetMetricDataV2Outcome GetMetricDataV2(const Model::GetMetricDataV2Request& request) const;
 
        template<typename GetMetricDataV2RequestT = Model::GetMetricDataV2Request>
        Model::GetMetricDataV2OutcomeCallable GetMetricDataV2Callable(const GetMetricDataV2RequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetMetricDataV2, request);
        }
 
        template<typename GetMetricDataV2RequestT = Model::GetMetricDataV2Request>
        void GetMetricDataV2Async(const GetMetricDataV2RequestT& request, const GetMetricDataV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetMetricDataV2, request, handler, context);
        }
 
        virtual Model::GetPromptFileOutcome GetPromptFile(const Model::GetPromptFileRequest& request) const;
 
        template<typename GetPromptFileRequestT = Model::GetPromptFileRequest>
        Model::GetPromptFileOutcomeCallable GetPromptFileCallable(const GetPromptFileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetPromptFile, request);
        }
 
        template<typename GetPromptFileRequestT = Model::GetPromptFileRequest>
        void GetPromptFileAsync(const GetPromptFileRequestT& request, const GetPromptFileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetPromptFile, request, handler, context);
        }
 
        virtual Model::GetTaskTemplateOutcome GetTaskTemplate(const Model::GetTaskTemplateRequest& request) const;
 
        template<typename GetTaskTemplateRequestT = Model::GetTaskTemplateRequest>
        Model::GetTaskTemplateOutcomeCallable GetTaskTemplateCallable(const GetTaskTemplateRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetTaskTemplate, request);
        }
 
        template<typename GetTaskTemplateRequestT = Model::GetTaskTemplateRequest>
        void GetTaskTemplateAsync(const GetTaskTemplateRequestT& request, const GetTaskTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetTaskTemplate, request, handler, context);
        }
 
        virtual Model::GetTrafficDistributionOutcome GetTrafficDistribution(const Model::GetTrafficDistributionRequest& request) const;
 
        template<typename GetTrafficDistributionRequestT = Model::GetTrafficDistributionRequest>
        Model::GetTrafficDistributionOutcomeCallable GetTrafficDistributionCallable(const GetTrafficDistributionRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::GetTrafficDistribution, request);
        }
 
        template<typename GetTrafficDistributionRequestT = Model::GetTrafficDistributionRequest>
        void GetTrafficDistributionAsync(const GetTrafficDistributionRequestT& request, const GetTrafficDistributionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::GetTrafficDistribution, request, handler, context);
        }
 
        virtual Model::ImportPhoneNumberOutcome ImportPhoneNumber(const Model::ImportPhoneNumberRequest& request) const;
 
        template<typename ImportPhoneNumberRequestT = Model::ImportPhoneNumberRequest>
        Model::ImportPhoneNumberOutcomeCallable ImportPhoneNumberCallable(const ImportPhoneNumberRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ImportPhoneNumber, request);
        }
 
        template<typename ImportPhoneNumberRequestT = Model::ImportPhoneNumberRequest>
        void ImportPhoneNumberAsync(const ImportPhoneNumberRequestT& request, const ImportPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ImportPhoneNumber, request, handler, context);
        }
 
        virtual Model::ListAgentStatusesOutcome ListAgentStatuses(const Model::ListAgentStatusesRequest& request) const;
 
        template<typename ListAgentStatusesRequestT = Model::ListAgentStatusesRequest>
        Model::ListAgentStatusesOutcomeCallable ListAgentStatusesCallable(const ListAgentStatusesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListAgentStatuses, request);
        }
 
        template<typename ListAgentStatusesRequestT = Model::ListAgentStatusesRequest>
        void ListAgentStatusesAsync(const ListAgentStatusesRequestT& request, const ListAgentStatusesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListAgentStatuses, request, handler, context);
        }
 
        virtual Model::ListAnalyticsDataAssociationsOutcome ListAnalyticsDataAssociations(const Model::ListAnalyticsDataAssociationsRequest& request) const;
 
        template<typename ListAnalyticsDataAssociationsRequestT = Model::ListAnalyticsDataAssociationsRequest>
        Model::ListAnalyticsDataAssociationsOutcomeCallable ListAnalyticsDataAssociationsCallable(const ListAnalyticsDataAssociationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListAnalyticsDataAssociations, request);
        }
 
        template<typename ListAnalyticsDataAssociationsRequestT = Model::ListAnalyticsDataAssociationsRequest>
        void ListAnalyticsDataAssociationsAsync(const ListAnalyticsDataAssociationsRequestT& request, const ListAnalyticsDataAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListAnalyticsDataAssociations, request, handler, context);
        }
 
        virtual Model::ListApprovedOriginsOutcome ListApprovedOrigins(const Model::ListApprovedOriginsRequest& request) const;
 
        template<typename ListApprovedOriginsRequestT = Model::ListApprovedOriginsRequest>
        Model::ListApprovedOriginsOutcomeCallable ListApprovedOriginsCallable(const ListApprovedOriginsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListApprovedOrigins, request);
        }
 
        template<typename ListApprovedOriginsRequestT = Model::ListApprovedOriginsRequest>
        void ListApprovedOriginsAsync(const ListApprovedOriginsRequestT& request, const ListApprovedOriginsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListApprovedOrigins, request, handler, context);
        }
 
        virtual Model::ListAuthenticationProfilesOutcome ListAuthenticationProfiles(const Model::ListAuthenticationProfilesRequest& request) const;
 
        template<typename ListAuthenticationProfilesRequestT = Model::ListAuthenticationProfilesRequest>
        Model::ListAuthenticationProfilesOutcomeCallable ListAuthenticationProfilesCallable(const ListAuthenticationProfilesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListAuthenticationProfiles, request);
        }
 
        template<typename ListAuthenticationProfilesRequestT = Model::ListAuthenticationProfilesRequest>
        void ListAuthenticationProfilesAsync(const ListAuthenticationProfilesRequestT& request, const ListAuthenticationProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListAuthenticationProfiles, request, handler, context);
        }
 
        virtual Model::ListBotsOutcome ListBots(const Model::ListBotsRequest& request) const;
 
        template<typename ListBotsRequestT = Model::ListBotsRequest>
        Model::ListBotsOutcomeCallable ListBotsCallable(const ListBotsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListBots, request);
        }
 
        template<typename ListBotsRequestT = Model::ListBotsRequest>
        void ListBotsAsync(const ListBotsRequestT& request, const ListBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListBots, request, handler, context);
        }
 
        virtual Model::ListContactEvaluationsOutcome ListContactEvaluations(const Model::ListContactEvaluationsRequest& request) const;
 
        template<typename ListContactEvaluationsRequestT = Model::ListContactEvaluationsRequest>
        Model::ListContactEvaluationsOutcomeCallable ListContactEvaluationsCallable(const ListContactEvaluationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListContactEvaluations, request);
        }
 
        template<typename ListContactEvaluationsRequestT = Model::ListContactEvaluationsRequest>
        void ListContactEvaluationsAsync(const ListContactEvaluationsRequestT& request, const ListContactEvaluationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListContactEvaluations, request, handler, context);
        }
 
        virtual Model::ListContactFlowModulesOutcome ListContactFlowModules(const Model::ListContactFlowModulesRequest& request) const;
 
        template<typename ListContactFlowModulesRequestT = Model::ListContactFlowModulesRequest>
        Model::ListContactFlowModulesOutcomeCallable ListContactFlowModulesCallable(const ListContactFlowModulesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListContactFlowModules, request);
        }
 
        template<typename ListContactFlowModulesRequestT = Model::ListContactFlowModulesRequest>
        void ListContactFlowModulesAsync(const ListContactFlowModulesRequestT& request, const ListContactFlowModulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListContactFlowModules, request, handler, context);
        }
 
        virtual Model::ListContactFlowsOutcome ListContactFlows(const Model::ListContactFlowsRequest& request) const;
 
        template<typename ListContactFlowsRequestT = Model::ListContactFlowsRequest>
        Model::ListContactFlowsOutcomeCallable ListContactFlowsCallable(const ListContactFlowsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListContactFlows, request);
        }
 
        template<typename ListContactFlowsRequestT = Model::ListContactFlowsRequest>
        void ListContactFlowsAsync(const ListContactFlowsRequestT& request, const ListContactFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListContactFlows, request, handler, context);
        }
 
        virtual Model::ListContactReferencesOutcome ListContactReferences(const Model::ListContactReferencesRequest& request) const;
 
        template<typename ListContactReferencesRequestT = Model::ListContactReferencesRequest>
        Model::ListContactReferencesOutcomeCallable ListContactReferencesCallable(const ListContactReferencesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListContactReferences, request);
        }
 
        template<typename ListContactReferencesRequestT = Model::ListContactReferencesRequest>
        void ListContactReferencesAsync(const ListContactReferencesRequestT& request, const ListContactReferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListContactReferences, request, handler, context);
        }
 
        virtual Model::ListDefaultVocabulariesOutcome ListDefaultVocabularies(const Model::ListDefaultVocabulariesRequest& request) const;
 
        template<typename ListDefaultVocabulariesRequestT = Model::ListDefaultVocabulariesRequest>
        Model::ListDefaultVocabulariesOutcomeCallable ListDefaultVocabulariesCallable(const ListDefaultVocabulariesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListDefaultVocabularies, request);
        }
 
        template<typename ListDefaultVocabulariesRequestT = Model::ListDefaultVocabulariesRequest>
        void ListDefaultVocabulariesAsync(const ListDefaultVocabulariesRequestT& request, const ListDefaultVocabulariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListDefaultVocabularies, request, handler, context);
        }
 
        virtual Model::ListEvaluationFormVersionsOutcome ListEvaluationFormVersions(const Model::ListEvaluationFormVersionsRequest& request) const;
 
        template<typename ListEvaluationFormVersionsRequestT = Model::ListEvaluationFormVersionsRequest>
        Model::ListEvaluationFormVersionsOutcomeCallable ListEvaluationFormVersionsCallable(const ListEvaluationFormVersionsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListEvaluationFormVersions, request);
        }
 
        template<typename ListEvaluationFormVersionsRequestT = Model::ListEvaluationFormVersionsRequest>
        void ListEvaluationFormVersionsAsync(const ListEvaluationFormVersionsRequestT& request, const ListEvaluationFormVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListEvaluationFormVersions, request, handler, context);
        }
 
        virtual Model::ListEvaluationFormsOutcome ListEvaluationForms(const Model::ListEvaluationFormsRequest& request) const;
 
        template<typename ListEvaluationFormsRequestT = Model::ListEvaluationFormsRequest>
        Model::ListEvaluationFormsOutcomeCallable ListEvaluationFormsCallable(const ListEvaluationFormsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListEvaluationForms, request);
        }
 
        template<typename ListEvaluationFormsRequestT = Model::ListEvaluationFormsRequest>
        void ListEvaluationFormsAsync(const ListEvaluationFormsRequestT& request, const ListEvaluationFormsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListEvaluationForms, request, handler, context);
        }
 
        virtual Model::ListFlowAssociationsOutcome ListFlowAssociations(const Model::ListFlowAssociationsRequest& request) const;
 
        template<typename ListFlowAssociationsRequestT = Model::ListFlowAssociationsRequest>
        Model::ListFlowAssociationsOutcomeCallable ListFlowAssociationsCallable(const ListFlowAssociationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListFlowAssociations, request);
        }
 
        template<typename ListFlowAssociationsRequestT = Model::ListFlowAssociationsRequest>
        void ListFlowAssociationsAsync(const ListFlowAssociationsRequestT& request, const ListFlowAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListFlowAssociations, request, handler, context);
        }
 
        virtual Model::ListHoursOfOperationsOutcome ListHoursOfOperations(const Model::ListHoursOfOperationsRequest& request) const;
 
        template<typename ListHoursOfOperationsRequestT = Model::ListHoursOfOperationsRequest>
        Model::ListHoursOfOperationsOutcomeCallable ListHoursOfOperationsCallable(const ListHoursOfOperationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListHoursOfOperations, request);
        }
 
        template<typename ListHoursOfOperationsRequestT = Model::ListHoursOfOperationsRequest>
        void ListHoursOfOperationsAsync(const ListHoursOfOperationsRequestT& request, const ListHoursOfOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListHoursOfOperations, request, handler, context);
        }
 
        virtual Model::ListInstanceAttributesOutcome ListInstanceAttributes(const Model::ListInstanceAttributesRequest& request) const;
 
        template<typename ListInstanceAttributesRequestT = Model::ListInstanceAttributesRequest>
        Model::ListInstanceAttributesOutcomeCallable ListInstanceAttributesCallable(const ListInstanceAttributesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListInstanceAttributes, request);
        }
 
        template<typename ListInstanceAttributesRequestT = Model::ListInstanceAttributesRequest>
        void ListInstanceAttributesAsync(const ListInstanceAttributesRequestT& request, const ListInstanceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListInstanceAttributes, request, handler, context);
        }
 
        virtual Model::ListInstanceStorageConfigsOutcome ListInstanceStorageConfigs(const Model::ListInstanceStorageConfigsRequest& request) const;
 
        template<typename ListInstanceStorageConfigsRequestT = Model::ListInstanceStorageConfigsRequest>
        Model::ListInstanceStorageConfigsOutcomeCallable ListInstanceStorageConfigsCallable(const ListInstanceStorageConfigsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListInstanceStorageConfigs, request);
        }
 
        template<typename ListInstanceStorageConfigsRequestT = Model::ListInstanceStorageConfigsRequest>
        void ListInstanceStorageConfigsAsync(const ListInstanceStorageConfigsRequestT& request, const ListInstanceStorageConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListInstanceStorageConfigs, request, handler, context);
        }
 
        virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request = {}) const;
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&ConnectClient::ListInstances, request);
        }
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        void ListInstancesAsync(const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&ConnectClient::ListInstances, request, handler, context);
        }
 
        virtual Model::ListIntegrationAssociationsOutcome ListIntegrationAssociations(const Model::ListIntegrationAssociationsRequest& request) const;
 
        template<typename ListIntegrationAssociationsRequestT = Model::ListIntegrationAssociationsRequest>
        Model::ListIntegrationAssociationsOutcomeCallable ListIntegrationAssociationsCallable(const ListIntegrationAssociationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListIntegrationAssociations, request);
        }
 
        template<typename ListIntegrationAssociationsRequestT = Model::ListIntegrationAssociationsRequest>
        void ListIntegrationAssociationsAsync(const ListIntegrationAssociationsRequestT& request, const ListIntegrationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListIntegrationAssociations, request, handler, context);
        }
 
        virtual Model::ListLambdaFunctionsOutcome ListLambdaFunctions(const Model::ListLambdaFunctionsRequest& request) const;
 
        template<typename ListLambdaFunctionsRequestT = Model::ListLambdaFunctionsRequest>
        Model::ListLambdaFunctionsOutcomeCallable ListLambdaFunctionsCallable(const ListLambdaFunctionsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListLambdaFunctions, request);
        }
 
        template<typename ListLambdaFunctionsRequestT = Model::ListLambdaFunctionsRequest>
        void ListLambdaFunctionsAsync(const ListLambdaFunctionsRequestT& request, const ListLambdaFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListLambdaFunctions, request, handler, context);
        }
 
        virtual Model::ListLexBotsOutcome ListLexBots(const Model::ListLexBotsRequest& request) const;
 
        template<typename ListLexBotsRequestT = Model::ListLexBotsRequest>
        Model::ListLexBotsOutcomeCallable ListLexBotsCallable(const ListLexBotsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListLexBots, request);
        }
 
        template<typename ListLexBotsRequestT = Model::ListLexBotsRequest>
        void ListLexBotsAsync(const ListLexBotsRequestT& request, const ListLexBotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListLexBots, request, handler, context);
        }
 
        virtual Model::ListPhoneNumbersOutcome ListPhoneNumbers(const Model::ListPhoneNumbersRequest& request) const;
 
        template<typename ListPhoneNumbersRequestT = Model::ListPhoneNumbersRequest>
        Model::ListPhoneNumbersOutcomeCallable ListPhoneNumbersCallable(const ListPhoneNumbersRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListPhoneNumbers, request);
        }
 
        template<typename ListPhoneNumbersRequestT = Model::ListPhoneNumbersRequest>
        void ListPhoneNumbersAsync(const ListPhoneNumbersRequestT& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListPhoneNumbers, request, handler, context);
        }
 
        virtual Model::ListPhoneNumbersV2Outcome ListPhoneNumbersV2(const Model::ListPhoneNumbersV2Request& request = {}) const;
 
        template<typename ListPhoneNumbersV2RequestT = Model::ListPhoneNumbersV2Request>
        Model::ListPhoneNumbersV2OutcomeCallable ListPhoneNumbersV2Callable(const ListPhoneNumbersV2RequestT& request = {}) const
        {
            return SubmitCallable(&ConnectClient::ListPhoneNumbersV2, request);
        }
 
        template<typename ListPhoneNumbersV2RequestT = Model::ListPhoneNumbersV2Request>
        void ListPhoneNumbersV2Async(const ListPhoneNumbersV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPhoneNumbersV2RequestT& request = {}) const
        {
            return SubmitAsync(&ConnectClient::ListPhoneNumbersV2, request, handler, context);
        }
 
        virtual Model::ListPredefinedAttributesOutcome ListPredefinedAttributes(const Model::ListPredefinedAttributesRequest& request) const;
 
        template<typename ListPredefinedAttributesRequestT = Model::ListPredefinedAttributesRequest>
        Model::ListPredefinedAttributesOutcomeCallable ListPredefinedAttributesCallable(const ListPredefinedAttributesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListPredefinedAttributes, request);
        }
 
        template<typename ListPredefinedAttributesRequestT = Model::ListPredefinedAttributesRequest>
        void ListPredefinedAttributesAsync(const ListPredefinedAttributesRequestT& request, const ListPredefinedAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListPredefinedAttributes, request, handler, context);
        }
 
        virtual Model::ListPromptsOutcome ListPrompts(const Model::ListPromptsRequest& request) const;
 
        template<typename ListPromptsRequestT = Model::ListPromptsRequest>
        Model::ListPromptsOutcomeCallable ListPromptsCallable(const ListPromptsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListPrompts, request);
        }
 
        template<typename ListPromptsRequestT = Model::ListPromptsRequest>
        void ListPromptsAsync(const ListPromptsRequestT& request, const ListPromptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListPrompts, request, handler, context);
        }
 
        virtual Model::ListQueueQuickConnectsOutcome ListQueueQuickConnects(const Model::ListQueueQuickConnectsRequest& request) const;
 
        template<typename ListQueueQuickConnectsRequestT = Model::ListQueueQuickConnectsRequest>
        Model::ListQueueQuickConnectsOutcomeCallable ListQueueQuickConnectsCallable(const ListQueueQuickConnectsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListQueueQuickConnects, request);
        }
 
        template<typename ListQueueQuickConnectsRequestT = Model::ListQueueQuickConnectsRequest>
        void ListQueueQuickConnectsAsync(const ListQueueQuickConnectsRequestT& request, const ListQueueQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListQueueQuickConnects, request, handler, context);
        }
 
        virtual Model::ListQueuesOutcome ListQueues(const Model::ListQueuesRequest& request) const;
 
        template<typename ListQueuesRequestT = Model::ListQueuesRequest>
        Model::ListQueuesOutcomeCallable ListQueuesCallable(const ListQueuesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListQueues, request);
        }
 
        template<typename ListQueuesRequestT = Model::ListQueuesRequest>
        void ListQueuesAsync(const ListQueuesRequestT& request, const ListQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListQueues, request, handler, context);
        }
 
        virtual Model::ListQuickConnectsOutcome ListQuickConnects(const Model::ListQuickConnectsRequest& request) const;
 
        template<typename ListQuickConnectsRequestT = Model::ListQuickConnectsRequest>
        Model::ListQuickConnectsOutcomeCallable ListQuickConnectsCallable(const ListQuickConnectsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListQuickConnects, request);
        }
 
        template<typename ListQuickConnectsRequestT = Model::ListQuickConnectsRequest>
        void ListQuickConnectsAsync(const ListQuickConnectsRequestT& request, const ListQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListQuickConnects, request, handler, context);
        }
 
        virtual Model::ListRealtimeContactAnalysisSegmentsV2Outcome ListRealtimeContactAnalysisSegmentsV2(const Model::ListRealtimeContactAnalysisSegmentsV2Request& request) const;
 
        template<typename ListRealtimeContactAnalysisSegmentsV2RequestT = Model::ListRealtimeContactAnalysisSegmentsV2Request>
        Model::ListRealtimeContactAnalysisSegmentsV2OutcomeCallable ListRealtimeContactAnalysisSegmentsV2Callable(const ListRealtimeContactAnalysisSegmentsV2RequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListRealtimeContactAnalysisSegmentsV2, request);
        }
 
        template<typename ListRealtimeContactAnalysisSegmentsV2RequestT = Model::ListRealtimeContactAnalysisSegmentsV2Request>
        void ListRealtimeContactAnalysisSegmentsV2Async(const ListRealtimeContactAnalysisSegmentsV2RequestT& request, const ListRealtimeContactAnalysisSegmentsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListRealtimeContactAnalysisSegmentsV2, request, handler, context);
        }
 
        virtual Model::ListRoutingProfileQueuesOutcome ListRoutingProfileQueues(const Model::ListRoutingProfileQueuesRequest& request) const;
 
        template<typename ListRoutingProfileQueuesRequestT = Model::ListRoutingProfileQueuesRequest>
        Model::ListRoutingProfileQueuesOutcomeCallable ListRoutingProfileQueuesCallable(const ListRoutingProfileQueuesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListRoutingProfileQueues, request);
        }
 
        template<typename ListRoutingProfileQueuesRequestT = Model::ListRoutingProfileQueuesRequest>
        void ListRoutingProfileQueuesAsync(const ListRoutingProfileQueuesRequestT& request, const ListRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListRoutingProfileQueues, request, handler, context);
        }
 
        virtual Model::ListRoutingProfilesOutcome ListRoutingProfiles(const Model::ListRoutingProfilesRequest& request) const;
 
        template<typename ListRoutingProfilesRequestT = Model::ListRoutingProfilesRequest>
        Model::ListRoutingProfilesOutcomeCallable ListRoutingProfilesCallable(const ListRoutingProfilesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListRoutingProfiles, request);
        }
 
        template<typename ListRoutingProfilesRequestT = Model::ListRoutingProfilesRequest>
        void ListRoutingProfilesAsync(const ListRoutingProfilesRequestT& request, const ListRoutingProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListRoutingProfiles, request, handler, context);
        }
 
        virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request) const;
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListRules, request);
        }
 
        template<typename ListRulesRequestT = Model::ListRulesRequest>
        void ListRulesAsync(const ListRulesRequestT& request, const ListRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListRules, request, handler, context);
        }
 
        virtual Model::ListSecurityKeysOutcome ListSecurityKeys(const Model::ListSecurityKeysRequest& request) const;
 
        template<typename ListSecurityKeysRequestT = Model::ListSecurityKeysRequest>
        Model::ListSecurityKeysOutcomeCallable ListSecurityKeysCallable(const ListSecurityKeysRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListSecurityKeys, request);
        }
 
        template<typename ListSecurityKeysRequestT = Model::ListSecurityKeysRequest>
        void ListSecurityKeysAsync(const ListSecurityKeysRequestT& request, const ListSecurityKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListSecurityKeys, request, handler, context);
        }
 
        virtual Model::ListSecurityProfileApplicationsOutcome ListSecurityProfileApplications(const Model::ListSecurityProfileApplicationsRequest& request) const;
 
        template<typename ListSecurityProfileApplicationsRequestT = Model::ListSecurityProfileApplicationsRequest>
        Model::ListSecurityProfileApplicationsOutcomeCallable ListSecurityProfileApplicationsCallable(const ListSecurityProfileApplicationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListSecurityProfileApplications, request);
        }
 
        template<typename ListSecurityProfileApplicationsRequestT = Model::ListSecurityProfileApplicationsRequest>
        void ListSecurityProfileApplicationsAsync(const ListSecurityProfileApplicationsRequestT& request, const ListSecurityProfileApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListSecurityProfileApplications, request, handler, context);
        }
 
        virtual Model::ListSecurityProfilePermissionsOutcome ListSecurityProfilePermissions(const Model::ListSecurityProfilePermissionsRequest& request) const;
 
        template<typename ListSecurityProfilePermissionsRequestT = Model::ListSecurityProfilePermissionsRequest>
        Model::ListSecurityProfilePermissionsOutcomeCallable ListSecurityProfilePermissionsCallable(const ListSecurityProfilePermissionsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListSecurityProfilePermissions, request);
        }
 
        template<typename ListSecurityProfilePermissionsRequestT = Model::ListSecurityProfilePermissionsRequest>
        void ListSecurityProfilePermissionsAsync(const ListSecurityProfilePermissionsRequestT& request, const ListSecurityProfilePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListSecurityProfilePermissions, request, handler, context);
        }
 
        virtual Model::ListSecurityProfilesOutcome ListSecurityProfiles(const Model::ListSecurityProfilesRequest& request) const;
 
        template<typename ListSecurityProfilesRequestT = Model::ListSecurityProfilesRequest>
        Model::ListSecurityProfilesOutcomeCallable ListSecurityProfilesCallable(const ListSecurityProfilesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListSecurityProfiles, request);
        }
 
        template<typename ListSecurityProfilesRequestT = Model::ListSecurityProfilesRequest>
        void ListSecurityProfilesAsync(const ListSecurityProfilesRequestT& request, const ListSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListSecurityProfiles, 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(&ConnectClient::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(&ConnectClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTaskTemplatesOutcome ListTaskTemplates(const Model::ListTaskTemplatesRequest& request) const;
 
        template<typename ListTaskTemplatesRequestT = Model::ListTaskTemplatesRequest>
        Model::ListTaskTemplatesOutcomeCallable ListTaskTemplatesCallable(const ListTaskTemplatesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListTaskTemplates, request);
        }
 
        template<typename ListTaskTemplatesRequestT = Model::ListTaskTemplatesRequest>
        void ListTaskTemplatesAsync(const ListTaskTemplatesRequestT& request, const ListTaskTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListTaskTemplates, request, handler, context);
        }
 
        virtual Model::ListTrafficDistributionGroupUsersOutcome ListTrafficDistributionGroupUsers(const Model::ListTrafficDistributionGroupUsersRequest& request) const;
 
        template<typename ListTrafficDistributionGroupUsersRequestT = Model::ListTrafficDistributionGroupUsersRequest>
        Model::ListTrafficDistributionGroupUsersOutcomeCallable ListTrafficDistributionGroupUsersCallable(const ListTrafficDistributionGroupUsersRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListTrafficDistributionGroupUsers, request);
        }
 
        template<typename ListTrafficDistributionGroupUsersRequestT = Model::ListTrafficDistributionGroupUsersRequest>
        void ListTrafficDistributionGroupUsersAsync(const ListTrafficDistributionGroupUsersRequestT& request, const ListTrafficDistributionGroupUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListTrafficDistributionGroupUsers, request, handler, context);
        }
 
        virtual Model::ListTrafficDistributionGroupsOutcome ListTrafficDistributionGroups(const Model::ListTrafficDistributionGroupsRequest& request = {}) const;
 
        template<typename ListTrafficDistributionGroupsRequestT = Model::ListTrafficDistributionGroupsRequest>
        Model::ListTrafficDistributionGroupsOutcomeCallable ListTrafficDistributionGroupsCallable(const ListTrafficDistributionGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ConnectClient::ListTrafficDistributionGroups, request);
        }
 
        template<typename ListTrafficDistributionGroupsRequestT = Model::ListTrafficDistributionGroupsRequest>
        void ListTrafficDistributionGroupsAsync(const ListTrafficDistributionGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTrafficDistributionGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ConnectClient::ListTrafficDistributionGroups, request, handler, context);
        }
 
        virtual Model::ListUseCasesOutcome ListUseCases(const Model::ListUseCasesRequest& request) const;
 
        template<typename ListUseCasesRequestT = Model::ListUseCasesRequest>
        Model::ListUseCasesOutcomeCallable ListUseCasesCallable(const ListUseCasesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListUseCases, request);
        }
 
        template<typename ListUseCasesRequestT = Model::ListUseCasesRequest>
        void ListUseCasesAsync(const ListUseCasesRequestT& request, const ListUseCasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListUseCases, request, handler, context);
        }
 
        virtual Model::ListUserHierarchyGroupsOutcome ListUserHierarchyGroups(const Model::ListUserHierarchyGroupsRequest& request) const;
 
        template<typename ListUserHierarchyGroupsRequestT = Model::ListUserHierarchyGroupsRequest>
        Model::ListUserHierarchyGroupsOutcomeCallable ListUserHierarchyGroupsCallable(const ListUserHierarchyGroupsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListUserHierarchyGroups, request);
        }
 
        template<typename ListUserHierarchyGroupsRequestT = Model::ListUserHierarchyGroupsRequest>
        void ListUserHierarchyGroupsAsync(const ListUserHierarchyGroupsRequestT& request, const ListUserHierarchyGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListUserHierarchyGroups, request, handler, context);
        }
 
        virtual Model::ListUserProficienciesOutcome ListUserProficiencies(const Model::ListUserProficienciesRequest& request) const;
 
        template<typename ListUserProficienciesRequestT = Model::ListUserProficienciesRequest>
        Model::ListUserProficienciesOutcomeCallable ListUserProficienciesCallable(const ListUserProficienciesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListUserProficiencies, request);
        }
 
        template<typename ListUserProficienciesRequestT = Model::ListUserProficienciesRequest>
        void ListUserProficienciesAsync(const ListUserProficienciesRequestT& request, const ListUserProficienciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListUserProficiencies, request, handler, context);
        }
 
        virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
        template<typename ListUsersRequestT = Model::ListUsersRequest>
        Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListUsers, request);
        }
 
        template<typename ListUsersRequestT = Model::ListUsersRequest>
        void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListUsers, request, handler, context);
        }
 
        virtual Model::ListViewVersionsOutcome ListViewVersions(const Model::ListViewVersionsRequest& request) const;
 
        template<typename ListViewVersionsRequestT = Model::ListViewVersionsRequest>
        Model::ListViewVersionsOutcomeCallable ListViewVersionsCallable(const ListViewVersionsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListViewVersions, request);
        }
 
        template<typename ListViewVersionsRequestT = Model::ListViewVersionsRequest>
        void ListViewVersionsAsync(const ListViewVersionsRequestT& request, const ListViewVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListViewVersions, request, handler, context);
        }
 
        virtual Model::ListViewsOutcome ListViews(const Model::ListViewsRequest& request) const;
 
        template<typename ListViewsRequestT = Model::ListViewsRequest>
        Model::ListViewsOutcomeCallable ListViewsCallable(const ListViewsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ListViews, request);
        }
 
        template<typename ListViewsRequestT = Model::ListViewsRequest>
        void ListViewsAsync(const ListViewsRequestT& request, const ListViewsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ListViews, request, handler, context);
        }
 
        virtual Model::MonitorContactOutcome MonitorContact(const Model::MonitorContactRequest& request) const;
 
        template<typename MonitorContactRequestT = Model::MonitorContactRequest>
        Model::MonitorContactOutcomeCallable MonitorContactCallable(const MonitorContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::MonitorContact, request);
        }
 
        template<typename MonitorContactRequestT = Model::MonitorContactRequest>
        void MonitorContactAsync(const MonitorContactRequestT& request, const MonitorContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::MonitorContact, request, handler, context);
        }
 
        virtual Model::PauseContactOutcome PauseContact(const Model::PauseContactRequest& request) const;
 
        template<typename PauseContactRequestT = Model::PauseContactRequest>
        Model::PauseContactOutcomeCallable PauseContactCallable(const PauseContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::PauseContact, request);
        }
 
        template<typename PauseContactRequestT = Model::PauseContactRequest>
        void PauseContactAsync(const PauseContactRequestT& request, const PauseContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::PauseContact, request, handler, context);
        }
 
        virtual Model::PutUserStatusOutcome PutUserStatus(const Model::PutUserStatusRequest& request) const;
 
        template<typename PutUserStatusRequestT = Model::PutUserStatusRequest>
        Model::PutUserStatusOutcomeCallable PutUserStatusCallable(const PutUserStatusRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::PutUserStatus, request);
        }
 
        template<typename PutUserStatusRequestT = Model::PutUserStatusRequest>
        void PutUserStatusAsync(const PutUserStatusRequestT& request, const PutUserStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::PutUserStatus, request, handler, context);
        }
 
        virtual Model::ReleasePhoneNumberOutcome ReleasePhoneNumber(const Model::ReleasePhoneNumberRequest& request) const;
 
        template<typename ReleasePhoneNumberRequestT = Model::ReleasePhoneNumberRequest>
        Model::ReleasePhoneNumberOutcomeCallable ReleasePhoneNumberCallable(const ReleasePhoneNumberRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ReleasePhoneNumber, request);
        }
 
        template<typename ReleasePhoneNumberRequestT = Model::ReleasePhoneNumberRequest>
        void ReleasePhoneNumberAsync(const ReleasePhoneNumberRequestT& request, const ReleasePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ReleasePhoneNumber, request, handler, context);
        }
 
        virtual Model::ReplicateInstanceOutcome ReplicateInstance(const Model::ReplicateInstanceRequest& request) const;
 
        template<typename ReplicateInstanceRequestT = Model::ReplicateInstanceRequest>
        Model::ReplicateInstanceOutcomeCallable ReplicateInstanceCallable(const ReplicateInstanceRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ReplicateInstance, request);
        }
 
        template<typename ReplicateInstanceRequestT = Model::ReplicateInstanceRequest>
        void ReplicateInstanceAsync(const ReplicateInstanceRequestT& request, const ReplicateInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ReplicateInstance, request, handler, context);
        }
 
        virtual Model::ResumeContactOutcome ResumeContact(const Model::ResumeContactRequest& request) const;
 
        template<typename ResumeContactRequestT = Model::ResumeContactRequest>
        Model::ResumeContactOutcomeCallable ResumeContactCallable(const ResumeContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ResumeContact, request);
        }
 
        template<typename ResumeContactRequestT = Model::ResumeContactRequest>
        void ResumeContactAsync(const ResumeContactRequestT& request, const ResumeContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ResumeContact, request, handler, context);
        }
 
        virtual Model::ResumeContactRecordingOutcome ResumeContactRecording(const Model::ResumeContactRecordingRequest& request) const;
 
        template<typename ResumeContactRecordingRequestT = Model::ResumeContactRecordingRequest>
        Model::ResumeContactRecordingOutcomeCallable ResumeContactRecordingCallable(const ResumeContactRecordingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::ResumeContactRecording, request);
        }
 
        template<typename ResumeContactRecordingRequestT = Model::ResumeContactRecordingRequest>
        void ResumeContactRecordingAsync(const ResumeContactRecordingRequestT& request, const ResumeContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::ResumeContactRecording, request, handler, context);
        }
 
        virtual Model::SearchAgentStatusesOutcome SearchAgentStatuses(const Model::SearchAgentStatusesRequest& request) const;
 
        template<typename SearchAgentStatusesRequestT = Model::SearchAgentStatusesRequest>
        Model::SearchAgentStatusesOutcomeCallable SearchAgentStatusesCallable(const SearchAgentStatusesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchAgentStatuses, request);
        }
 
        template<typename SearchAgentStatusesRequestT = Model::SearchAgentStatusesRequest>
        void SearchAgentStatusesAsync(const SearchAgentStatusesRequestT& request, const SearchAgentStatusesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchAgentStatuses, request, handler, context);
        }
 
        virtual Model::SearchAvailablePhoneNumbersOutcome SearchAvailablePhoneNumbers(const Model::SearchAvailablePhoneNumbersRequest& request) const;
 
        template<typename SearchAvailablePhoneNumbersRequestT = Model::SearchAvailablePhoneNumbersRequest>
        Model::SearchAvailablePhoneNumbersOutcomeCallable SearchAvailablePhoneNumbersCallable(const SearchAvailablePhoneNumbersRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchAvailablePhoneNumbers, request);
        }
 
        template<typename SearchAvailablePhoneNumbersRequestT = Model::SearchAvailablePhoneNumbersRequest>
        void SearchAvailablePhoneNumbersAsync(const SearchAvailablePhoneNumbersRequestT& request, const SearchAvailablePhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchAvailablePhoneNumbers, request, handler, context);
        }
 
        virtual Model::SearchContactFlowModulesOutcome SearchContactFlowModules(const Model::SearchContactFlowModulesRequest& request) const;
 
        template<typename SearchContactFlowModulesRequestT = Model::SearchContactFlowModulesRequest>
        Model::SearchContactFlowModulesOutcomeCallable SearchContactFlowModulesCallable(const SearchContactFlowModulesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchContactFlowModules, request);
        }
 
        template<typename SearchContactFlowModulesRequestT = Model::SearchContactFlowModulesRequest>
        void SearchContactFlowModulesAsync(const SearchContactFlowModulesRequestT& request, const SearchContactFlowModulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchContactFlowModules, request, handler, context);
        }
 
        virtual Model::SearchContactFlowsOutcome SearchContactFlows(const Model::SearchContactFlowsRequest& request) const;
 
        template<typename SearchContactFlowsRequestT = Model::SearchContactFlowsRequest>
        Model::SearchContactFlowsOutcomeCallable SearchContactFlowsCallable(const SearchContactFlowsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchContactFlows, request);
        }
 
        template<typename SearchContactFlowsRequestT = Model::SearchContactFlowsRequest>
        void SearchContactFlowsAsync(const SearchContactFlowsRequestT& request, const SearchContactFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchContactFlows, request, handler, context);
        }
 
        virtual Model::SearchContactsOutcome SearchContacts(const Model::SearchContactsRequest& request) const;
 
        template<typename SearchContactsRequestT = Model::SearchContactsRequest>
        Model::SearchContactsOutcomeCallable SearchContactsCallable(const SearchContactsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchContacts, request);
        }
 
        template<typename SearchContactsRequestT = Model::SearchContactsRequest>
        void SearchContactsAsync(const SearchContactsRequestT& request, const SearchContactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchContacts, request, handler, context);
        }
 
        virtual Model::SearchHoursOfOperationsOutcome SearchHoursOfOperations(const Model::SearchHoursOfOperationsRequest& request) const;
 
        template<typename SearchHoursOfOperationsRequestT = Model::SearchHoursOfOperationsRequest>
        Model::SearchHoursOfOperationsOutcomeCallable SearchHoursOfOperationsCallable(const SearchHoursOfOperationsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchHoursOfOperations, request);
        }
 
        template<typename SearchHoursOfOperationsRequestT = Model::SearchHoursOfOperationsRequest>
        void SearchHoursOfOperationsAsync(const SearchHoursOfOperationsRequestT& request, const SearchHoursOfOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchHoursOfOperations, request, handler, context);
        }
 
        virtual Model::SearchPredefinedAttributesOutcome SearchPredefinedAttributes(const Model::SearchPredefinedAttributesRequest& request) const;
 
        template<typename SearchPredefinedAttributesRequestT = Model::SearchPredefinedAttributesRequest>
        Model::SearchPredefinedAttributesOutcomeCallable SearchPredefinedAttributesCallable(const SearchPredefinedAttributesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchPredefinedAttributes, request);
        }
 
        template<typename SearchPredefinedAttributesRequestT = Model::SearchPredefinedAttributesRequest>
        void SearchPredefinedAttributesAsync(const SearchPredefinedAttributesRequestT& request, const SearchPredefinedAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchPredefinedAttributes, request, handler, context);
        }
 
        virtual Model::SearchPromptsOutcome SearchPrompts(const Model::SearchPromptsRequest& request) const;
 
        template<typename SearchPromptsRequestT = Model::SearchPromptsRequest>
        Model::SearchPromptsOutcomeCallable SearchPromptsCallable(const SearchPromptsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchPrompts, request);
        }
 
        template<typename SearchPromptsRequestT = Model::SearchPromptsRequest>
        void SearchPromptsAsync(const SearchPromptsRequestT& request, const SearchPromptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchPrompts, request, handler, context);
        }
 
        virtual Model::SearchQueuesOutcome SearchQueues(const Model::SearchQueuesRequest& request) const;
 
        template<typename SearchQueuesRequestT = Model::SearchQueuesRequest>
        Model::SearchQueuesOutcomeCallable SearchQueuesCallable(const SearchQueuesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchQueues, request);
        }
 
        template<typename SearchQueuesRequestT = Model::SearchQueuesRequest>
        void SearchQueuesAsync(const SearchQueuesRequestT& request, const SearchQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchQueues, request, handler, context);
        }
 
        virtual Model::SearchQuickConnectsOutcome SearchQuickConnects(const Model::SearchQuickConnectsRequest& request) const;
 
        template<typename SearchQuickConnectsRequestT = Model::SearchQuickConnectsRequest>
        Model::SearchQuickConnectsOutcomeCallable SearchQuickConnectsCallable(const SearchQuickConnectsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchQuickConnects, request);
        }
 
        template<typename SearchQuickConnectsRequestT = Model::SearchQuickConnectsRequest>
        void SearchQuickConnectsAsync(const SearchQuickConnectsRequestT& request, const SearchQuickConnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchQuickConnects, request, handler, context);
        }
 
        virtual Model::SearchResourceTagsOutcome SearchResourceTags(const Model::SearchResourceTagsRequest& request) const;
 
        template<typename SearchResourceTagsRequestT = Model::SearchResourceTagsRequest>
        Model::SearchResourceTagsOutcomeCallable SearchResourceTagsCallable(const SearchResourceTagsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchResourceTags, request);
        }
 
        template<typename SearchResourceTagsRequestT = Model::SearchResourceTagsRequest>
        void SearchResourceTagsAsync(const SearchResourceTagsRequestT& request, const SearchResourceTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchResourceTags, request, handler, context);
        }
 
        virtual Model::SearchRoutingProfilesOutcome SearchRoutingProfiles(const Model::SearchRoutingProfilesRequest& request) const;
 
        template<typename SearchRoutingProfilesRequestT = Model::SearchRoutingProfilesRequest>
        Model::SearchRoutingProfilesOutcomeCallable SearchRoutingProfilesCallable(const SearchRoutingProfilesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchRoutingProfiles, request);
        }
 
        template<typename SearchRoutingProfilesRequestT = Model::SearchRoutingProfilesRequest>
        void SearchRoutingProfilesAsync(const SearchRoutingProfilesRequestT& request, const SearchRoutingProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchRoutingProfiles, request, handler, context);
        }
 
        virtual Model::SearchSecurityProfilesOutcome SearchSecurityProfiles(const Model::SearchSecurityProfilesRequest& request) const;
 
        template<typename SearchSecurityProfilesRequestT = Model::SearchSecurityProfilesRequest>
        Model::SearchSecurityProfilesOutcomeCallable SearchSecurityProfilesCallable(const SearchSecurityProfilesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchSecurityProfiles, request);
        }
 
        template<typename SearchSecurityProfilesRequestT = Model::SearchSecurityProfilesRequest>
        void SearchSecurityProfilesAsync(const SearchSecurityProfilesRequestT& request, const SearchSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchSecurityProfiles, request, handler, context);
        }
 
        virtual Model::SearchUserHierarchyGroupsOutcome SearchUserHierarchyGroups(const Model::SearchUserHierarchyGroupsRequest& request) const;
 
        template<typename SearchUserHierarchyGroupsRequestT = Model::SearchUserHierarchyGroupsRequest>
        Model::SearchUserHierarchyGroupsOutcomeCallable SearchUserHierarchyGroupsCallable(const SearchUserHierarchyGroupsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchUserHierarchyGroups, request);
        }
 
        template<typename SearchUserHierarchyGroupsRequestT = Model::SearchUserHierarchyGroupsRequest>
        void SearchUserHierarchyGroupsAsync(const SearchUserHierarchyGroupsRequestT& request, const SearchUserHierarchyGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchUserHierarchyGroups, request, handler, context);
        }
 
        virtual Model::SearchUsersOutcome SearchUsers(const Model::SearchUsersRequest& request) const;
 
        template<typename SearchUsersRequestT = Model::SearchUsersRequest>
        Model::SearchUsersOutcomeCallable SearchUsersCallable(const SearchUsersRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchUsers, request);
        }
 
        template<typename SearchUsersRequestT = Model::SearchUsersRequest>
        void SearchUsersAsync(const SearchUsersRequestT& request, const SearchUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchUsers, request, handler, context);
        }
 
        virtual Model::SearchVocabulariesOutcome SearchVocabularies(const Model::SearchVocabulariesRequest& request) const;
 
        template<typename SearchVocabulariesRequestT = Model::SearchVocabulariesRequest>
        Model::SearchVocabulariesOutcomeCallable SearchVocabulariesCallable(const SearchVocabulariesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SearchVocabularies, request);
        }
 
        template<typename SearchVocabulariesRequestT = Model::SearchVocabulariesRequest>
        void SearchVocabulariesAsync(const SearchVocabulariesRequestT& request, const SearchVocabulariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SearchVocabularies, request, handler, context);
        }
 
        virtual Model::SendChatIntegrationEventOutcome SendChatIntegrationEvent(const Model::SendChatIntegrationEventRequest& request) const;
 
        template<typename SendChatIntegrationEventRequestT = Model::SendChatIntegrationEventRequest>
        Model::SendChatIntegrationEventOutcomeCallable SendChatIntegrationEventCallable(const SendChatIntegrationEventRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SendChatIntegrationEvent, request);
        }
 
        template<typename SendChatIntegrationEventRequestT = Model::SendChatIntegrationEventRequest>
        void SendChatIntegrationEventAsync(const SendChatIntegrationEventRequestT& request, const SendChatIntegrationEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SendChatIntegrationEvent, request, handler, context);
        }
 
        virtual Model::StartAttachedFileUploadOutcome StartAttachedFileUpload(const Model::StartAttachedFileUploadRequest& request) const;
 
        template<typename StartAttachedFileUploadRequestT = Model::StartAttachedFileUploadRequest>
        Model::StartAttachedFileUploadOutcomeCallable StartAttachedFileUploadCallable(const StartAttachedFileUploadRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartAttachedFileUpload, request);
        }
 
        template<typename StartAttachedFileUploadRequestT = Model::StartAttachedFileUploadRequest>
        void StartAttachedFileUploadAsync(const StartAttachedFileUploadRequestT& request, const StartAttachedFileUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartAttachedFileUpload, request, handler, context);
        }
 
        virtual Model::StartChatContactOutcome StartChatContact(const Model::StartChatContactRequest& request) const;
 
        template<typename StartChatContactRequestT = Model::StartChatContactRequest>
        Model::StartChatContactOutcomeCallable StartChatContactCallable(const StartChatContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartChatContact, request);
        }
 
        template<typename StartChatContactRequestT = Model::StartChatContactRequest>
        void StartChatContactAsync(const StartChatContactRequestT& request, const StartChatContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartChatContact, request, handler, context);
        }
 
        virtual Model::StartContactEvaluationOutcome StartContactEvaluation(const Model::StartContactEvaluationRequest& request) const;
 
        template<typename StartContactEvaluationRequestT = Model::StartContactEvaluationRequest>
        Model::StartContactEvaluationOutcomeCallable StartContactEvaluationCallable(const StartContactEvaluationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartContactEvaluation, request);
        }
 
        template<typename StartContactEvaluationRequestT = Model::StartContactEvaluationRequest>
        void StartContactEvaluationAsync(const StartContactEvaluationRequestT& request, const StartContactEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartContactEvaluation, request, handler, context);
        }
 
        virtual Model::StartContactRecordingOutcome StartContactRecording(const Model::StartContactRecordingRequest& request) const;
 
        template<typename StartContactRecordingRequestT = Model::StartContactRecordingRequest>
        Model::StartContactRecordingOutcomeCallable StartContactRecordingCallable(const StartContactRecordingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartContactRecording, request);
        }
 
        template<typename StartContactRecordingRequestT = Model::StartContactRecordingRequest>
        void StartContactRecordingAsync(const StartContactRecordingRequestT& request, const StartContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartContactRecording, request, handler, context);
        }
 
        virtual Model::StartContactStreamingOutcome StartContactStreaming(const Model::StartContactStreamingRequest& request) const;
 
        template<typename StartContactStreamingRequestT = Model::StartContactStreamingRequest>
        Model::StartContactStreamingOutcomeCallable StartContactStreamingCallable(const StartContactStreamingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartContactStreaming, request);
        }
 
        template<typename StartContactStreamingRequestT = Model::StartContactStreamingRequest>
        void StartContactStreamingAsync(const StartContactStreamingRequestT& request, const StartContactStreamingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartContactStreaming, request, handler, context);
        }
 
        virtual Model::StartOutboundChatContactOutcome StartOutboundChatContact(const Model::StartOutboundChatContactRequest& request) const;
 
        template<typename StartOutboundChatContactRequestT = Model::StartOutboundChatContactRequest>
        Model::StartOutboundChatContactOutcomeCallable StartOutboundChatContactCallable(const StartOutboundChatContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartOutboundChatContact, request);
        }
 
        template<typename StartOutboundChatContactRequestT = Model::StartOutboundChatContactRequest>
        void StartOutboundChatContactAsync(const StartOutboundChatContactRequestT& request, const StartOutboundChatContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartOutboundChatContact, request, handler, context);
        }
 
        virtual Model::StartOutboundVoiceContactOutcome StartOutboundVoiceContact(const Model::StartOutboundVoiceContactRequest& request) const;
 
        template<typename StartOutboundVoiceContactRequestT = Model::StartOutboundVoiceContactRequest>
        Model::StartOutboundVoiceContactOutcomeCallable StartOutboundVoiceContactCallable(const StartOutboundVoiceContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartOutboundVoiceContact, request);
        }
 
        template<typename StartOutboundVoiceContactRequestT = Model::StartOutboundVoiceContactRequest>
        void StartOutboundVoiceContactAsync(const StartOutboundVoiceContactRequestT& request, const StartOutboundVoiceContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartOutboundVoiceContact, request, handler, context);
        }
 
        virtual Model::StartScreenSharingOutcome StartScreenSharing(const Model::StartScreenSharingRequest& request) const;
 
        template<typename StartScreenSharingRequestT = Model::StartScreenSharingRequest>
        Model::StartScreenSharingOutcomeCallable StartScreenSharingCallable(const StartScreenSharingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartScreenSharing, request);
        }
 
        template<typename StartScreenSharingRequestT = Model::StartScreenSharingRequest>
        void StartScreenSharingAsync(const StartScreenSharingRequestT& request, const StartScreenSharingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartScreenSharing, request, handler, context);
        }
 
        virtual Model::StartTaskContactOutcome StartTaskContact(const Model::StartTaskContactRequest& request) const;
 
        template<typename StartTaskContactRequestT = Model::StartTaskContactRequest>
        Model::StartTaskContactOutcomeCallable StartTaskContactCallable(const StartTaskContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartTaskContact, request);
        }
 
        template<typename StartTaskContactRequestT = Model::StartTaskContactRequest>
        void StartTaskContactAsync(const StartTaskContactRequestT& request, const StartTaskContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartTaskContact, request, handler, context);
        }
 
        virtual Model::StartWebRTCContactOutcome StartWebRTCContact(const Model::StartWebRTCContactRequest& request) const;
 
        template<typename StartWebRTCContactRequestT = Model::StartWebRTCContactRequest>
        Model::StartWebRTCContactOutcomeCallable StartWebRTCContactCallable(const StartWebRTCContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StartWebRTCContact, request);
        }
 
        template<typename StartWebRTCContactRequestT = Model::StartWebRTCContactRequest>
        void StartWebRTCContactAsync(const StartWebRTCContactRequestT& request, const StartWebRTCContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StartWebRTCContact, request, handler, context);
        }
 
        virtual Model::StopContactOutcome StopContact(const Model::StopContactRequest& request) const;
 
        template<typename StopContactRequestT = Model::StopContactRequest>
        Model::StopContactOutcomeCallable StopContactCallable(const StopContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StopContact, request);
        }
 
        template<typename StopContactRequestT = Model::StopContactRequest>
        void StopContactAsync(const StopContactRequestT& request, const StopContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StopContact, request, handler, context);
        }
 
        virtual Model::StopContactRecordingOutcome StopContactRecording(const Model::StopContactRecordingRequest& request) const;
 
        template<typename StopContactRecordingRequestT = Model::StopContactRecordingRequest>
        Model::StopContactRecordingOutcomeCallable StopContactRecordingCallable(const StopContactRecordingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StopContactRecording, request);
        }
 
        template<typename StopContactRecordingRequestT = Model::StopContactRecordingRequest>
        void StopContactRecordingAsync(const StopContactRecordingRequestT& request, const StopContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StopContactRecording, request, handler, context);
        }
 
        virtual Model::StopContactStreamingOutcome StopContactStreaming(const Model::StopContactStreamingRequest& request) const;
 
        template<typename StopContactStreamingRequestT = Model::StopContactStreamingRequest>
        Model::StopContactStreamingOutcomeCallable StopContactStreamingCallable(const StopContactStreamingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::StopContactStreaming, request);
        }
 
        template<typename StopContactStreamingRequestT = Model::StopContactStreamingRequest>
        void StopContactStreamingAsync(const StopContactStreamingRequestT& request, const StopContactStreamingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::StopContactStreaming, request, handler, context);
        }
 
        virtual Model::SubmitContactEvaluationOutcome SubmitContactEvaluation(const Model::SubmitContactEvaluationRequest& request) const;
 
        template<typename SubmitContactEvaluationRequestT = Model::SubmitContactEvaluationRequest>
        Model::SubmitContactEvaluationOutcomeCallable SubmitContactEvaluationCallable(const SubmitContactEvaluationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SubmitContactEvaluation, request);
        }
 
        template<typename SubmitContactEvaluationRequestT = Model::SubmitContactEvaluationRequest>
        void SubmitContactEvaluationAsync(const SubmitContactEvaluationRequestT& request, const SubmitContactEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SubmitContactEvaluation, request, handler, context);
        }
 
        virtual Model::SuspendContactRecordingOutcome SuspendContactRecording(const Model::SuspendContactRecordingRequest& request) const;
 
        template<typename SuspendContactRecordingRequestT = Model::SuspendContactRecordingRequest>
        Model::SuspendContactRecordingOutcomeCallable SuspendContactRecordingCallable(const SuspendContactRecordingRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::SuspendContactRecording, request);
        }
 
        template<typename SuspendContactRecordingRequestT = Model::SuspendContactRecordingRequest>
        void SuspendContactRecordingAsync(const SuspendContactRecordingRequestT& request, const SuspendContactRecordingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::SuspendContactRecording, request, handler, context);
        }
 
        virtual Model::TagContactOutcome TagContact(const Model::TagContactRequest& request) const;
 
        template<typename TagContactRequestT = Model::TagContactRequest>
        Model::TagContactOutcomeCallable TagContactCallable(const TagContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::TagContact, request);
        }
 
        template<typename TagContactRequestT = Model::TagContactRequest>
        void TagContactAsync(const TagContactRequestT& request, const TagContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::TagContact, 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(&ConnectClient::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(&ConnectClient::TagResource, request, handler, context);
        }
 
        virtual Model::TransferContactOutcome TransferContact(const Model::TransferContactRequest& request) const;
 
        template<typename TransferContactRequestT = Model::TransferContactRequest>
        Model::TransferContactOutcomeCallable TransferContactCallable(const TransferContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::TransferContact, request);
        }
 
        template<typename TransferContactRequestT = Model::TransferContactRequest>
        void TransferContactAsync(const TransferContactRequestT& request, const TransferContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::TransferContact, request, handler, context);
        }
 
        virtual Model::UntagContactOutcome UntagContact(const Model::UntagContactRequest& request) const;
 
        template<typename UntagContactRequestT = Model::UntagContactRequest>
        Model::UntagContactOutcomeCallable UntagContactCallable(const UntagContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UntagContact, request);
        }
 
        template<typename UntagContactRequestT = Model::UntagContactRequest>
        void UntagContactAsync(const UntagContactRequestT& request, const UntagContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UntagContact, 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(&ConnectClient::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(&ConnectClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAgentStatusOutcome UpdateAgentStatus(const Model::UpdateAgentStatusRequest& request) const;
 
        template<typename UpdateAgentStatusRequestT = Model::UpdateAgentStatusRequest>
        Model::UpdateAgentStatusOutcomeCallable UpdateAgentStatusCallable(const UpdateAgentStatusRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateAgentStatus, request);
        }
 
        template<typename UpdateAgentStatusRequestT = Model::UpdateAgentStatusRequest>
        void UpdateAgentStatusAsync(const UpdateAgentStatusRequestT& request, const UpdateAgentStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateAgentStatus, request, handler, context);
        }
 
        virtual Model::UpdateAuthenticationProfileOutcome UpdateAuthenticationProfile(const Model::UpdateAuthenticationProfileRequest& request) const;
 
        template<typename UpdateAuthenticationProfileRequestT = Model::UpdateAuthenticationProfileRequest>
        Model::UpdateAuthenticationProfileOutcomeCallable UpdateAuthenticationProfileCallable(const UpdateAuthenticationProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateAuthenticationProfile, request);
        }
 
        template<typename UpdateAuthenticationProfileRequestT = Model::UpdateAuthenticationProfileRequest>
        void UpdateAuthenticationProfileAsync(const UpdateAuthenticationProfileRequestT& request, const UpdateAuthenticationProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateAuthenticationProfile, request, handler, context);
        }
 
        virtual Model::UpdateContactOutcome UpdateContact(const Model::UpdateContactRequest& request) const;
 
        template<typename UpdateContactRequestT = Model::UpdateContactRequest>
        Model::UpdateContactOutcomeCallable UpdateContactCallable(const UpdateContactRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContact, request);
        }
 
        template<typename UpdateContactRequestT = Model::UpdateContactRequest>
        void UpdateContactAsync(const UpdateContactRequestT& request, const UpdateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContact, request, handler, context);
        }
 
        virtual Model::UpdateContactAttributesOutcome UpdateContactAttributes(const Model::UpdateContactAttributesRequest& request) const;
 
        template<typename UpdateContactAttributesRequestT = Model::UpdateContactAttributesRequest>
        Model::UpdateContactAttributesOutcomeCallable UpdateContactAttributesCallable(const UpdateContactAttributesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactAttributes, request);
        }
 
        template<typename UpdateContactAttributesRequestT = Model::UpdateContactAttributesRequest>
        void UpdateContactAttributesAsync(const UpdateContactAttributesRequestT& request, const UpdateContactAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactAttributes, request, handler, context);
        }
 
        virtual Model::UpdateContactEvaluationOutcome UpdateContactEvaluation(const Model::UpdateContactEvaluationRequest& request) const;
 
        template<typename UpdateContactEvaluationRequestT = Model::UpdateContactEvaluationRequest>
        Model::UpdateContactEvaluationOutcomeCallable UpdateContactEvaluationCallable(const UpdateContactEvaluationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactEvaluation, request);
        }
 
        template<typename UpdateContactEvaluationRequestT = Model::UpdateContactEvaluationRequest>
        void UpdateContactEvaluationAsync(const UpdateContactEvaluationRequestT& request, const UpdateContactEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactEvaluation, request, handler, context);
        }
 
        virtual Model::UpdateContactFlowContentOutcome UpdateContactFlowContent(const Model::UpdateContactFlowContentRequest& request) const;
 
        template<typename UpdateContactFlowContentRequestT = Model::UpdateContactFlowContentRequest>
        Model::UpdateContactFlowContentOutcomeCallable UpdateContactFlowContentCallable(const UpdateContactFlowContentRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactFlowContent, request);
        }
 
        template<typename UpdateContactFlowContentRequestT = Model::UpdateContactFlowContentRequest>
        void UpdateContactFlowContentAsync(const UpdateContactFlowContentRequestT& request, const UpdateContactFlowContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactFlowContent, request, handler, context);
        }
 
        virtual Model::UpdateContactFlowMetadataOutcome UpdateContactFlowMetadata(const Model::UpdateContactFlowMetadataRequest& request) const;
 
        template<typename UpdateContactFlowMetadataRequestT = Model::UpdateContactFlowMetadataRequest>
        Model::UpdateContactFlowMetadataOutcomeCallable UpdateContactFlowMetadataCallable(const UpdateContactFlowMetadataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactFlowMetadata, request);
        }
 
        template<typename UpdateContactFlowMetadataRequestT = Model::UpdateContactFlowMetadataRequest>
        void UpdateContactFlowMetadataAsync(const UpdateContactFlowMetadataRequestT& request, const UpdateContactFlowMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactFlowMetadata, request, handler, context);
        }
 
        virtual Model::UpdateContactFlowModuleContentOutcome UpdateContactFlowModuleContent(const Model::UpdateContactFlowModuleContentRequest& request) const;
 
        template<typename UpdateContactFlowModuleContentRequestT = Model::UpdateContactFlowModuleContentRequest>
        Model::UpdateContactFlowModuleContentOutcomeCallable UpdateContactFlowModuleContentCallable(const UpdateContactFlowModuleContentRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactFlowModuleContent, request);
        }
 
        template<typename UpdateContactFlowModuleContentRequestT = Model::UpdateContactFlowModuleContentRequest>
        void UpdateContactFlowModuleContentAsync(const UpdateContactFlowModuleContentRequestT& request, const UpdateContactFlowModuleContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactFlowModuleContent, request, handler, context);
        }
 
        virtual Model::UpdateContactFlowModuleMetadataOutcome UpdateContactFlowModuleMetadata(const Model::UpdateContactFlowModuleMetadataRequest& request) const;
 
        template<typename UpdateContactFlowModuleMetadataRequestT = Model::UpdateContactFlowModuleMetadataRequest>
        Model::UpdateContactFlowModuleMetadataOutcomeCallable UpdateContactFlowModuleMetadataCallable(const UpdateContactFlowModuleMetadataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactFlowModuleMetadata, request);
        }
 
        template<typename UpdateContactFlowModuleMetadataRequestT = Model::UpdateContactFlowModuleMetadataRequest>
        void UpdateContactFlowModuleMetadataAsync(const UpdateContactFlowModuleMetadataRequestT& request, const UpdateContactFlowModuleMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactFlowModuleMetadata, request, handler, context);
        }
 
        virtual Model::UpdateContactFlowNameOutcome UpdateContactFlowName(const Model::UpdateContactFlowNameRequest& request) const;
 
        template<typename UpdateContactFlowNameRequestT = Model::UpdateContactFlowNameRequest>
        Model::UpdateContactFlowNameOutcomeCallable UpdateContactFlowNameCallable(const UpdateContactFlowNameRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactFlowName, request);
        }
 
        template<typename UpdateContactFlowNameRequestT = Model::UpdateContactFlowNameRequest>
        void UpdateContactFlowNameAsync(const UpdateContactFlowNameRequestT& request, const UpdateContactFlowNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactFlowName, request, handler, context);
        }
 
        virtual Model::UpdateContactRoutingDataOutcome UpdateContactRoutingData(const Model::UpdateContactRoutingDataRequest& request) const;
 
        template<typename UpdateContactRoutingDataRequestT = Model::UpdateContactRoutingDataRequest>
        Model::UpdateContactRoutingDataOutcomeCallable UpdateContactRoutingDataCallable(const UpdateContactRoutingDataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactRoutingData, request);
        }
 
        template<typename UpdateContactRoutingDataRequestT = Model::UpdateContactRoutingDataRequest>
        void UpdateContactRoutingDataAsync(const UpdateContactRoutingDataRequestT& request, const UpdateContactRoutingDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactRoutingData, request, handler, context);
        }
 
        virtual Model::UpdateContactScheduleOutcome UpdateContactSchedule(const Model::UpdateContactScheduleRequest& request) const;
 
        template<typename UpdateContactScheduleRequestT = Model::UpdateContactScheduleRequest>
        Model::UpdateContactScheduleOutcomeCallable UpdateContactScheduleCallable(const UpdateContactScheduleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateContactSchedule, request);
        }
 
        template<typename UpdateContactScheduleRequestT = Model::UpdateContactScheduleRequest>
        void UpdateContactScheduleAsync(const UpdateContactScheduleRequestT& request, const UpdateContactScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateContactSchedule, request, handler, context);
        }
 
        virtual Model::UpdateEvaluationFormOutcome UpdateEvaluationForm(const Model::UpdateEvaluationFormRequest& request) const;
 
        template<typename UpdateEvaluationFormRequestT = Model::UpdateEvaluationFormRequest>
        Model::UpdateEvaluationFormOutcomeCallable UpdateEvaluationFormCallable(const UpdateEvaluationFormRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateEvaluationForm, request);
        }
 
        template<typename UpdateEvaluationFormRequestT = Model::UpdateEvaluationFormRequest>
        void UpdateEvaluationFormAsync(const UpdateEvaluationFormRequestT& request, const UpdateEvaluationFormResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateEvaluationForm, request, handler, context);
        }
 
        virtual Model::UpdateHoursOfOperationOutcome UpdateHoursOfOperation(const Model::UpdateHoursOfOperationRequest& request) const;
 
        template<typename UpdateHoursOfOperationRequestT = Model::UpdateHoursOfOperationRequest>
        Model::UpdateHoursOfOperationOutcomeCallable UpdateHoursOfOperationCallable(const UpdateHoursOfOperationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateHoursOfOperation, request);
        }
 
        template<typename UpdateHoursOfOperationRequestT = Model::UpdateHoursOfOperationRequest>
        void UpdateHoursOfOperationAsync(const UpdateHoursOfOperationRequestT& request, const UpdateHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateHoursOfOperation, request, handler, context);
        }
 
        virtual Model::UpdateInstanceAttributeOutcome UpdateInstanceAttribute(const Model::UpdateInstanceAttributeRequest& request) const;
 
        template<typename UpdateInstanceAttributeRequestT = Model::UpdateInstanceAttributeRequest>
        Model::UpdateInstanceAttributeOutcomeCallable UpdateInstanceAttributeCallable(const UpdateInstanceAttributeRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateInstanceAttribute, request);
        }
 
        template<typename UpdateInstanceAttributeRequestT = Model::UpdateInstanceAttributeRequest>
        void UpdateInstanceAttributeAsync(const UpdateInstanceAttributeRequestT& request, const UpdateInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateInstanceAttribute, request, handler, context);
        }
 
        virtual Model::UpdateInstanceStorageConfigOutcome UpdateInstanceStorageConfig(const Model::UpdateInstanceStorageConfigRequest& request) const;
 
        template<typename UpdateInstanceStorageConfigRequestT = Model::UpdateInstanceStorageConfigRequest>
        Model::UpdateInstanceStorageConfigOutcomeCallable UpdateInstanceStorageConfigCallable(const UpdateInstanceStorageConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateInstanceStorageConfig, request);
        }
 
        template<typename UpdateInstanceStorageConfigRequestT = Model::UpdateInstanceStorageConfigRequest>
        void UpdateInstanceStorageConfigAsync(const UpdateInstanceStorageConfigRequestT& request, const UpdateInstanceStorageConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateInstanceStorageConfig, request, handler, context);
        }
 
        virtual Model::UpdateParticipantRoleConfigOutcome UpdateParticipantRoleConfig(const Model::UpdateParticipantRoleConfigRequest& request) const;
 
        template<typename UpdateParticipantRoleConfigRequestT = Model::UpdateParticipantRoleConfigRequest>
        Model::UpdateParticipantRoleConfigOutcomeCallable UpdateParticipantRoleConfigCallable(const UpdateParticipantRoleConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateParticipantRoleConfig, request);
        }
 
        template<typename UpdateParticipantRoleConfigRequestT = Model::UpdateParticipantRoleConfigRequest>
        void UpdateParticipantRoleConfigAsync(const UpdateParticipantRoleConfigRequestT& request, const UpdateParticipantRoleConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateParticipantRoleConfig, request, handler, context);
        }
 
        virtual Model::UpdatePhoneNumberOutcome UpdatePhoneNumber(const Model::UpdatePhoneNumberRequest& request) const;
 
        template<typename UpdatePhoneNumberRequestT = Model::UpdatePhoneNumberRequest>
        Model::UpdatePhoneNumberOutcomeCallable UpdatePhoneNumberCallable(const UpdatePhoneNumberRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdatePhoneNumber, request);
        }
 
        template<typename UpdatePhoneNumberRequestT = Model::UpdatePhoneNumberRequest>
        void UpdatePhoneNumberAsync(const UpdatePhoneNumberRequestT& request, const UpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdatePhoneNumber, request, handler, context);
        }
 
        virtual Model::UpdatePhoneNumberMetadataOutcome UpdatePhoneNumberMetadata(const Model::UpdatePhoneNumberMetadataRequest& request) const;
 
        template<typename UpdatePhoneNumberMetadataRequestT = Model::UpdatePhoneNumberMetadataRequest>
        Model::UpdatePhoneNumberMetadataOutcomeCallable UpdatePhoneNumberMetadataCallable(const UpdatePhoneNumberMetadataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdatePhoneNumberMetadata, request);
        }
 
        template<typename UpdatePhoneNumberMetadataRequestT = Model::UpdatePhoneNumberMetadataRequest>
        void UpdatePhoneNumberMetadataAsync(const UpdatePhoneNumberMetadataRequestT& request, const UpdatePhoneNumberMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdatePhoneNumberMetadata, request, handler, context);
        }
 
        virtual Model::UpdatePredefinedAttributeOutcome UpdatePredefinedAttribute(const Model::UpdatePredefinedAttributeRequest& request) const;
 
        template<typename UpdatePredefinedAttributeRequestT = Model::UpdatePredefinedAttributeRequest>
        Model::UpdatePredefinedAttributeOutcomeCallable UpdatePredefinedAttributeCallable(const UpdatePredefinedAttributeRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdatePredefinedAttribute, request);
        }
 
        template<typename UpdatePredefinedAttributeRequestT = Model::UpdatePredefinedAttributeRequest>
        void UpdatePredefinedAttributeAsync(const UpdatePredefinedAttributeRequestT& request, const UpdatePredefinedAttributeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdatePredefinedAttribute, request, handler, context);
        }
 
        virtual Model::UpdatePromptOutcome UpdatePrompt(const Model::UpdatePromptRequest& request) const;
 
        template<typename UpdatePromptRequestT = Model::UpdatePromptRequest>
        Model::UpdatePromptOutcomeCallable UpdatePromptCallable(const UpdatePromptRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdatePrompt, request);
        }
 
        template<typename UpdatePromptRequestT = Model::UpdatePromptRequest>
        void UpdatePromptAsync(const UpdatePromptRequestT& request, const UpdatePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdatePrompt, request, handler, context);
        }
 
        virtual Model::UpdateQueueHoursOfOperationOutcome UpdateQueueHoursOfOperation(const Model::UpdateQueueHoursOfOperationRequest& request) const;
 
        template<typename UpdateQueueHoursOfOperationRequestT = Model::UpdateQueueHoursOfOperationRequest>
        Model::UpdateQueueHoursOfOperationOutcomeCallable UpdateQueueHoursOfOperationCallable(const UpdateQueueHoursOfOperationRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQueueHoursOfOperation, request);
        }
 
        template<typename UpdateQueueHoursOfOperationRequestT = Model::UpdateQueueHoursOfOperationRequest>
        void UpdateQueueHoursOfOperationAsync(const UpdateQueueHoursOfOperationRequestT& request, const UpdateQueueHoursOfOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQueueHoursOfOperation, request, handler, context);
        }
 
        virtual Model::UpdateQueueMaxContactsOutcome UpdateQueueMaxContacts(const Model::UpdateQueueMaxContactsRequest& request) const;
 
        template<typename UpdateQueueMaxContactsRequestT = Model::UpdateQueueMaxContactsRequest>
        Model::UpdateQueueMaxContactsOutcomeCallable UpdateQueueMaxContactsCallable(const UpdateQueueMaxContactsRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQueueMaxContacts, request);
        }
 
        template<typename UpdateQueueMaxContactsRequestT = Model::UpdateQueueMaxContactsRequest>
        void UpdateQueueMaxContactsAsync(const UpdateQueueMaxContactsRequestT& request, const UpdateQueueMaxContactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQueueMaxContacts, request, handler, context);
        }
 
        virtual Model::UpdateQueueNameOutcome UpdateQueueName(const Model::UpdateQueueNameRequest& request) const;
 
        template<typename UpdateQueueNameRequestT = Model::UpdateQueueNameRequest>
        Model::UpdateQueueNameOutcomeCallable UpdateQueueNameCallable(const UpdateQueueNameRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQueueName, request);
        }
 
        template<typename UpdateQueueNameRequestT = Model::UpdateQueueNameRequest>
        void UpdateQueueNameAsync(const UpdateQueueNameRequestT& request, const UpdateQueueNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQueueName, request, handler, context);
        }
 
        virtual Model::UpdateQueueOutboundCallerConfigOutcome UpdateQueueOutboundCallerConfig(const Model::UpdateQueueOutboundCallerConfigRequest& request) const;
 
        template<typename UpdateQueueOutboundCallerConfigRequestT = Model::UpdateQueueOutboundCallerConfigRequest>
        Model::UpdateQueueOutboundCallerConfigOutcomeCallable UpdateQueueOutboundCallerConfigCallable(const UpdateQueueOutboundCallerConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQueueOutboundCallerConfig, request);
        }
 
        template<typename UpdateQueueOutboundCallerConfigRequestT = Model::UpdateQueueOutboundCallerConfigRequest>
        void UpdateQueueOutboundCallerConfigAsync(const UpdateQueueOutboundCallerConfigRequestT& request, const UpdateQueueOutboundCallerConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQueueOutboundCallerConfig, request, handler, context);
        }
 
        virtual Model::UpdateQueueStatusOutcome UpdateQueueStatus(const Model::UpdateQueueStatusRequest& request) const;
 
        template<typename UpdateQueueStatusRequestT = Model::UpdateQueueStatusRequest>
        Model::UpdateQueueStatusOutcomeCallable UpdateQueueStatusCallable(const UpdateQueueStatusRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQueueStatus, request);
        }
 
        template<typename UpdateQueueStatusRequestT = Model::UpdateQueueStatusRequest>
        void UpdateQueueStatusAsync(const UpdateQueueStatusRequestT& request, const UpdateQueueStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQueueStatus, request, handler, context);
        }
 
        virtual Model::UpdateQuickConnectConfigOutcome UpdateQuickConnectConfig(const Model::UpdateQuickConnectConfigRequest& request) const;
 
        template<typename UpdateQuickConnectConfigRequestT = Model::UpdateQuickConnectConfigRequest>
        Model::UpdateQuickConnectConfigOutcomeCallable UpdateQuickConnectConfigCallable(const UpdateQuickConnectConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQuickConnectConfig, request);
        }
 
        template<typename UpdateQuickConnectConfigRequestT = Model::UpdateQuickConnectConfigRequest>
        void UpdateQuickConnectConfigAsync(const UpdateQuickConnectConfigRequestT& request, const UpdateQuickConnectConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQuickConnectConfig, request, handler, context);
        }
 
        virtual Model::UpdateQuickConnectNameOutcome UpdateQuickConnectName(const Model::UpdateQuickConnectNameRequest& request) const;
 
        template<typename UpdateQuickConnectNameRequestT = Model::UpdateQuickConnectNameRequest>
        Model::UpdateQuickConnectNameOutcomeCallable UpdateQuickConnectNameCallable(const UpdateQuickConnectNameRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateQuickConnectName, request);
        }
 
        template<typename UpdateQuickConnectNameRequestT = Model::UpdateQuickConnectNameRequest>
        void UpdateQuickConnectNameAsync(const UpdateQuickConnectNameRequestT& request, const UpdateQuickConnectNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateQuickConnectName, request, handler, context);
        }
 
        virtual Model::UpdateRoutingProfileAgentAvailabilityTimerOutcome UpdateRoutingProfileAgentAvailabilityTimer(const Model::UpdateRoutingProfileAgentAvailabilityTimerRequest& request) const;
 
        template<typename UpdateRoutingProfileAgentAvailabilityTimerRequestT = Model::UpdateRoutingProfileAgentAvailabilityTimerRequest>
        Model::UpdateRoutingProfileAgentAvailabilityTimerOutcomeCallable UpdateRoutingProfileAgentAvailabilityTimerCallable(const UpdateRoutingProfileAgentAvailabilityTimerRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateRoutingProfileAgentAvailabilityTimer, request);
        }
 
        template<typename UpdateRoutingProfileAgentAvailabilityTimerRequestT = Model::UpdateRoutingProfileAgentAvailabilityTimerRequest>
        void UpdateRoutingProfileAgentAvailabilityTimerAsync(const UpdateRoutingProfileAgentAvailabilityTimerRequestT& request, const UpdateRoutingProfileAgentAvailabilityTimerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateRoutingProfileAgentAvailabilityTimer, request, handler, context);
        }
 
        virtual Model::UpdateRoutingProfileConcurrencyOutcome UpdateRoutingProfileConcurrency(const Model::UpdateRoutingProfileConcurrencyRequest& request) const;
 
        template<typename UpdateRoutingProfileConcurrencyRequestT = Model::UpdateRoutingProfileConcurrencyRequest>
        Model::UpdateRoutingProfileConcurrencyOutcomeCallable UpdateRoutingProfileConcurrencyCallable(const UpdateRoutingProfileConcurrencyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateRoutingProfileConcurrency, request);
        }
 
        template<typename UpdateRoutingProfileConcurrencyRequestT = Model::UpdateRoutingProfileConcurrencyRequest>
        void UpdateRoutingProfileConcurrencyAsync(const UpdateRoutingProfileConcurrencyRequestT& request, const UpdateRoutingProfileConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateRoutingProfileConcurrency, request, handler, context);
        }
 
        virtual Model::UpdateRoutingProfileDefaultOutboundQueueOutcome UpdateRoutingProfileDefaultOutboundQueue(const Model::UpdateRoutingProfileDefaultOutboundQueueRequest& request) const;
 
        template<typename UpdateRoutingProfileDefaultOutboundQueueRequestT = Model::UpdateRoutingProfileDefaultOutboundQueueRequest>
        Model::UpdateRoutingProfileDefaultOutboundQueueOutcomeCallable UpdateRoutingProfileDefaultOutboundQueueCallable(const UpdateRoutingProfileDefaultOutboundQueueRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateRoutingProfileDefaultOutboundQueue, request);
        }
 
        template<typename UpdateRoutingProfileDefaultOutboundQueueRequestT = Model::UpdateRoutingProfileDefaultOutboundQueueRequest>
        void UpdateRoutingProfileDefaultOutboundQueueAsync(const UpdateRoutingProfileDefaultOutboundQueueRequestT& request, const UpdateRoutingProfileDefaultOutboundQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateRoutingProfileDefaultOutboundQueue, request, handler, context);
        }
 
        virtual Model::UpdateRoutingProfileNameOutcome UpdateRoutingProfileName(const Model::UpdateRoutingProfileNameRequest& request) const;
 
        template<typename UpdateRoutingProfileNameRequestT = Model::UpdateRoutingProfileNameRequest>
        Model::UpdateRoutingProfileNameOutcomeCallable UpdateRoutingProfileNameCallable(const UpdateRoutingProfileNameRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateRoutingProfileName, request);
        }
 
        template<typename UpdateRoutingProfileNameRequestT = Model::UpdateRoutingProfileNameRequest>
        void UpdateRoutingProfileNameAsync(const UpdateRoutingProfileNameRequestT& request, const UpdateRoutingProfileNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateRoutingProfileName, request, handler, context);
        }
 
        virtual Model::UpdateRoutingProfileQueuesOutcome UpdateRoutingProfileQueues(const Model::UpdateRoutingProfileQueuesRequest& request) const;
 
        template<typename UpdateRoutingProfileQueuesRequestT = Model::UpdateRoutingProfileQueuesRequest>
        Model::UpdateRoutingProfileQueuesOutcomeCallable UpdateRoutingProfileQueuesCallable(const UpdateRoutingProfileQueuesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateRoutingProfileQueues, request);
        }
 
        template<typename UpdateRoutingProfileQueuesRequestT = Model::UpdateRoutingProfileQueuesRequest>
        void UpdateRoutingProfileQueuesAsync(const UpdateRoutingProfileQueuesRequestT& request, const UpdateRoutingProfileQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateRoutingProfileQueues, request, handler, context);
        }
 
        virtual Model::UpdateRuleOutcome UpdateRule(const Model::UpdateRuleRequest& request) const;
 
        template<typename UpdateRuleRequestT = Model::UpdateRuleRequest>
        Model::UpdateRuleOutcomeCallable UpdateRuleCallable(const UpdateRuleRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateRule, request);
        }
 
        template<typename UpdateRuleRequestT = Model::UpdateRuleRequest>
        void UpdateRuleAsync(const UpdateRuleRequestT& request, const UpdateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateRule, request, handler, context);
        }
 
        virtual Model::UpdateSecurityProfileOutcome UpdateSecurityProfile(const Model::UpdateSecurityProfileRequest& request) const;
 
        template<typename UpdateSecurityProfileRequestT = Model::UpdateSecurityProfileRequest>
        Model::UpdateSecurityProfileOutcomeCallable UpdateSecurityProfileCallable(const UpdateSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateSecurityProfile, request);
        }
 
        template<typename UpdateSecurityProfileRequestT = Model::UpdateSecurityProfileRequest>
        void UpdateSecurityProfileAsync(const UpdateSecurityProfileRequestT& request, const UpdateSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateSecurityProfile, request, handler, context);
        }
 
        virtual Model::UpdateTaskTemplateOutcome UpdateTaskTemplate(const Model::UpdateTaskTemplateRequest& request) const;
 
        template<typename UpdateTaskTemplateRequestT = Model::UpdateTaskTemplateRequest>
        Model::UpdateTaskTemplateOutcomeCallable UpdateTaskTemplateCallable(const UpdateTaskTemplateRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateTaskTemplate, request);
        }
 
        template<typename UpdateTaskTemplateRequestT = Model::UpdateTaskTemplateRequest>
        void UpdateTaskTemplateAsync(const UpdateTaskTemplateRequestT& request, const UpdateTaskTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateTaskTemplate, request, handler, context);
        }
 
        virtual Model::UpdateTrafficDistributionOutcome UpdateTrafficDistribution(const Model::UpdateTrafficDistributionRequest& request) const;
 
        template<typename UpdateTrafficDistributionRequestT = Model::UpdateTrafficDistributionRequest>
        Model::UpdateTrafficDistributionOutcomeCallable UpdateTrafficDistributionCallable(const UpdateTrafficDistributionRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateTrafficDistribution, request);
        }
 
        template<typename UpdateTrafficDistributionRequestT = Model::UpdateTrafficDistributionRequest>
        void UpdateTrafficDistributionAsync(const UpdateTrafficDistributionRequestT& request, const UpdateTrafficDistributionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateTrafficDistribution, request, handler, context);
        }
 
        virtual Model::UpdateUserHierarchyOutcome UpdateUserHierarchy(const Model::UpdateUserHierarchyRequest& request) const;
 
        template<typename UpdateUserHierarchyRequestT = Model::UpdateUserHierarchyRequest>
        Model::UpdateUserHierarchyOutcomeCallable UpdateUserHierarchyCallable(const UpdateUserHierarchyRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserHierarchy, request);
        }
 
        template<typename UpdateUserHierarchyRequestT = Model::UpdateUserHierarchyRequest>
        void UpdateUserHierarchyAsync(const UpdateUserHierarchyRequestT& request, const UpdateUserHierarchyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserHierarchy, request, handler, context);
        }
 
        virtual Model::UpdateUserHierarchyGroupNameOutcome UpdateUserHierarchyGroupName(const Model::UpdateUserHierarchyGroupNameRequest& request) const;
 
        template<typename UpdateUserHierarchyGroupNameRequestT = Model::UpdateUserHierarchyGroupNameRequest>
        Model::UpdateUserHierarchyGroupNameOutcomeCallable UpdateUserHierarchyGroupNameCallable(const UpdateUserHierarchyGroupNameRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserHierarchyGroupName, request);
        }
 
        template<typename UpdateUserHierarchyGroupNameRequestT = Model::UpdateUserHierarchyGroupNameRequest>
        void UpdateUserHierarchyGroupNameAsync(const UpdateUserHierarchyGroupNameRequestT& request, const UpdateUserHierarchyGroupNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserHierarchyGroupName, request, handler, context);
        }
 
        virtual Model::UpdateUserHierarchyStructureOutcome UpdateUserHierarchyStructure(const Model::UpdateUserHierarchyStructureRequest& request) const;
 
        template<typename UpdateUserHierarchyStructureRequestT = Model::UpdateUserHierarchyStructureRequest>
        Model::UpdateUserHierarchyStructureOutcomeCallable UpdateUserHierarchyStructureCallable(const UpdateUserHierarchyStructureRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserHierarchyStructure, request);
        }
 
        template<typename UpdateUserHierarchyStructureRequestT = Model::UpdateUserHierarchyStructureRequest>
        void UpdateUserHierarchyStructureAsync(const UpdateUserHierarchyStructureRequestT& request, const UpdateUserHierarchyStructureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserHierarchyStructure, request, handler, context);
        }
 
        virtual Model::UpdateUserIdentityInfoOutcome UpdateUserIdentityInfo(const Model::UpdateUserIdentityInfoRequest& request) const;
 
        template<typename UpdateUserIdentityInfoRequestT = Model::UpdateUserIdentityInfoRequest>
        Model::UpdateUserIdentityInfoOutcomeCallable UpdateUserIdentityInfoCallable(const UpdateUserIdentityInfoRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserIdentityInfo, request);
        }
 
        template<typename UpdateUserIdentityInfoRequestT = Model::UpdateUserIdentityInfoRequest>
        void UpdateUserIdentityInfoAsync(const UpdateUserIdentityInfoRequestT& request, const UpdateUserIdentityInfoResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserIdentityInfo, request, handler, context);
        }
 
        virtual Model::UpdateUserPhoneConfigOutcome UpdateUserPhoneConfig(const Model::UpdateUserPhoneConfigRequest& request) const;
 
        template<typename UpdateUserPhoneConfigRequestT = Model::UpdateUserPhoneConfigRequest>
        Model::UpdateUserPhoneConfigOutcomeCallable UpdateUserPhoneConfigCallable(const UpdateUserPhoneConfigRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserPhoneConfig, request);
        }
 
        template<typename UpdateUserPhoneConfigRequestT = Model::UpdateUserPhoneConfigRequest>
        void UpdateUserPhoneConfigAsync(const UpdateUserPhoneConfigRequestT& request, const UpdateUserPhoneConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserPhoneConfig, request, handler, context);
        }
 
        virtual Model::UpdateUserProficienciesOutcome UpdateUserProficiencies(const Model::UpdateUserProficienciesRequest& request) const;
 
        template<typename UpdateUserProficienciesRequestT = Model::UpdateUserProficienciesRequest>
        Model::UpdateUserProficienciesOutcomeCallable UpdateUserProficienciesCallable(const UpdateUserProficienciesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserProficiencies, request);
        }
 
        template<typename UpdateUserProficienciesRequestT = Model::UpdateUserProficienciesRequest>
        void UpdateUserProficienciesAsync(const UpdateUserProficienciesRequestT& request, const UpdateUserProficienciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserProficiencies, request, handler, context);
        }
 
        virtual Model::UpdateUserRoutingProfileOutcome UpdateUserRoutingProfile(const Model::UpdateUserRoutingProfileRequest& request) const;
 
        template<typename UpdateUserRoutingProfileRequestT = Model::UpdateUserRoutingProfileRequest>
        Model::UpdateUserRoutingProfileOutcomeCallable UpdateUserRoutingProfileCallable(const UpdateUserRoutingProfileRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserRoutingProfile, request);
        }
 
        template<typename UpdateUserRoutingProfileRequestT = Model::UpdateUserRoutingProfileRequest>
        void UpdateUserRoutingProfileAsync(const UpdateUserRoutingProfileRequestT& request, const UpdateUserRoutingProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserRoutingProfile, request, handler, context);
        }
 
        virtual Model::UpdateUserSecurityProfilesOutcome UpdateUserSecurityProfiles(const Model::UpdateUserSecurityProfilesRequest& request) const;
 
        template<typename UpdateUserSecurityProfilesRequestT = Model::UpdateUserSecurityProfilesRequest>
        Model::UpdateUserSecurityProfilesOutcomeCallable UpdateUserSecurityProfilesCallable(const UpdateUserSecurityProfilesRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateUserSecurityProfiles, request);
        }
 
        template<typename UpdateUserSecurityProfilesRequestT = Model::UpdateUserSecurityProfilesRequest>
        void UpdateUserSecurityProfilesAsync(const UpdateUserSecurityProfilesRequestT& request, const UpdateUserSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateUserSecurityProfiles, request, handler, context);
        }
 
        virtual Model::UpdateViewContentOutcome UpdateViewContent(const Model::UpdateViewContentRequest& request) const;
 
        template<typename UpdateViewContentRequestT = Model::UpdateViewContentRequest>
        Model::UpdateViewContentOutcomeCallable UpdateViewContentCallable(const UpdateViewContentRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateViewContent, request);
        }
 
        template<typename UpdateViewContentRequestT = Model::UpdateViewContentRequest>
        void UpdateViewContentAsync(const UpdateViewContentRequestT& request, const UpdateViewContentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateViewContent, request, handler, context);
        }
 
        virtual Model::UpdateViewMetadataOutcome UpdateViewMetadata(const Model::UpdateViewMetadataRequest& request) const;
 
        template<typename UpdateViewMetadataRequestT = Model::UpdateViewMetadataRequest>
        Model::UpdateViewMetadataOutcomeCallable UpdateViewMetadataCallable(const UpdateViewMetadataRequestT& request) const
        {
            return SubmitCallable(&ConnectClient::UpdateViewMetadata, request);
        }
 
        template<typename UpdateViewMetadataRequestT = Model::UpdateViewMetadataRequest>
        void UpdateViewMetadataAsync(const UpdateViewMetadataRequestT& request, const UpdateViewMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ConnectClient::UpdateViewMetadata, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ConnectEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectClient>;
      void init(const ConnectClientConfiguration& clientConfiguration);
 
      ConnectClientConfiguration m_clientConfiguration;
      std::shared_ptr<ConnectEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Connect
} // namespace Aws