ConnectClient.h

 
#pragma once
#include <aws/connect/ConnectPaginationBase.h>
#include <aws/connect/ConnectServiceClientModel.h>
#include <aws/connect/ConnectWaiter.h>
#include <aws/connect/Connect_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace Connect {
class AWS_CONNECT_API ConnectClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<ConnectClient>,
                                      public ConnectPaginationBase<ConnectClient>,
                                      public ConnectWaiter<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::AssociateContactWithUserOutcome AssociateContactWithUser(const Model::AssociateContactWithUserRequest& request) const;
 
  template <typename AssociateContactWithUserRequestT = Model::AssociateContactWithUserRequest>
  Model::AssociateContactWithUserOutcomeCallable AssociateContactWithUserCallable(const AssociateContactWithUserRequestT& request) const {
    return SubmitCallable(&ConnectClient::AssociateContactWithUser, request);
  }
 
  template <typename AssociateContactWithUserRequestT = Model::AssociateContactWithUserRequest>
  void AssociateContactWithUserAsync(const AssociateContactWithUserRequestT& request,
                                     const AssociateContactWithUserResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::AssociateContactWithUser, 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::AssociateEmailAddressAliasOutcome AssociateEmailAddressAlias(
      const Model::AssociateEmailAddressAliasRequest& request) const;
 
  template <typename AssociateEmailAddressAliasRequestT = Model::AssociateEmailAddressAliasRequest>
  Model::AssociateEmailAddressAliasOutcomeCallable AssociateEmailAddressAliasCallable(
      const AssociateEmailAddressAliasRequestT& request) const {
    return SubmitCallable(&ConnectClient::AssociateEmailAddressAlias, request);
  }
 
  template <typename AssociateEmailAddressAliasRequestT = Model::AssociateEmailAddressAliasRequest>
  void AssociateEmailAddressAliasAsync(const AssociateEmailAddressAliasRequestT& request,
                                       const AssociateEmailAddressAliasResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::AssociateEmailAddressAlias, 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::AssociateHoursOfOperationsOutcome AssociateHoursOfOperations(
      const Model::AssociateHoursOfOperationsRequest& request) const;
 
  template <typename AssociateHoursOfOperationsRequestT = Model::AssociateHoursOfOperationsRequest>
  Model::AssociateHoursOfOperationsOutcomeCallable AssociateHoursOfOperationsCallable(
      const AssociateHoursOfOperationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::AssociateHoursOfOperations, request);
  }
 
  template <typename AssociateHoursOfOperationsRequestT = Model::AssociateHoursOfOperationsRequest>
  void AssociateHoursOfOperationsAsync(const AssociateHoursOfOperationsRequestT& request,
                                       const AssociateHoursOfOperationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::AssociateHoursOfOperations, 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::AssociateQueueEmailAddressesOutcome AssociateQueueEmailAddresses(
      const Model::AssociateQueueEmailAddressesRequest& request) const;
 
  template <typename AssociateQueueEmailAddressesRequestT = Model::AssociateQueueEmailAddressesRequest>
  Model::AssociateQueueEmailAddressesOutcomeCallable AssociateQueueEmailAddressesCallable(
      const AssociateQueueEmailAddressesRequestT& request) const {
    return SubmitCallable(&ConnectClient::AssociateQueueEmailAddresses, request);
  }
 
  template <typename AssociateQueueEmailAddressesRequestT = Model::AssociateQueueEmailAddressesRequest>
  void AssociateQueueEmailAddressesAsync(const AssociateQueueEmailAddressesRequestT& request,
                                         const AssociateQueueEmailAddressesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::AssociateQueueEmailAddresses, 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::AssociateSecurityProfilesOutcome AssociateSecurityProfiles(const Model::AssociateSecurityProfilesRequest& request) const;
 
  template <typename AssociateSecurityProfilesRequestT = Model::AssociateSecurityProfilesRequest>
  Model::AssociateSecurityProfilesOutcomeCallable AssociateSecurityProfilesCallable(
      const AssociateSecurityProfilesRequestT& request) const {
    return SubmitCallable(&ConnectClient::AssociateSecurityProfiles, request);
  }
 
  template <typename AssociateSecurityProfilesRequestT = Model::AssociateSecurityProfilesRequest>
  void AssociateSecurityProfilesAsync(const AssociateSecurityProfilesRequestT& request,
                                      const AssociateSecurityProfilesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::AssociateSecurityProfiles, 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::AssociateWorkspaceOutcome AssociateWorkspace(const Model::AssociateWorkspaceRequest& request) const;
 
  template <typename AssociateWorkspaceRequestT = Model::AssociateWorkspaceRequest>
  Model::AssociateWorkspaceOutcomeCallable AssociateWorkspaceCallable(const AssociateWorkspaceRequestT& request) const {
    return SubmitCallable(&ConnectClient::AssociateWorkspace, request);
  }
 
  template <typename AssociateWorkspaceRequestT = Model::AssociateWorkspaceRequest>
  void AssociateWorkspaceAsync(const AssociateWorkspaceRequestT& request, const AssociateWorkspaceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::AssociateWorkspace, 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::BatchCreateDataTableValueOutcome BatchCreateDataTableValue(const Model::BatchCreateDataTableValueRequest& request) const;
 
  template <typename BatchCreateDataTableValueRequestT = Model::BatchCreateDataTableValueRequest>
  Model::BatchCreateDataTableValueOutcomeCallable BatchCreateDataTableValueCallable(
      const BatchCreateDataTableValueRequestT& request) const {
    return SubmitCallable(&ConnectClient::BatchCreateDataTableValue, request);
  }
 
  template <typename BatchCreateDataTableValueRequestT = Model::BatchCreateDataTableValueRequest>
  void BatchCreateDataTableValueAsync(const BatchCreateDataTableValueRequestT& request,
                                      const BatchCreateDataTableValueResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::BatchCreateDataTableValue, request, handler, context);
  }
 
  virtual Model::BatchDeleteDataTableValueOutcome BatchDeleteDataTableValue(const Model::BatchDeleteDataTableValueRequest& request) const;
 
  template <typename BatchDeleteDataTableValueRequestT = Model::BatchDeleteDataTableValueRequest>
  Model::BatchDeleteDataTableValueOutcomeCallable BatchDeleteDataTableValueCallable(
      const BatchDeleteDataTableValueRequestT& request) const {
    return SubmitCallable(&ConnectClient::BatchDeleteDataTableValue, request);
  }
 
  template <typename BatchDeleteDataTableValueRequestT = Model::BatchDeleteDataTableValueRequest>
  void BatchDeleteDataTableValueAsync(const BatchDeleteDataTableValueRequestT& request,
                                      const BatchDeleteDataTableValueResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::BatchDeleteDataTableValue, request, handler, context);
  }
 
  virtual Model::BatchDescribeDataTableValueOutcome BatchDescribeDataTableValue(
      const Model::BatchDescribeDataTableValueRequest& request) const;
 
  template <typename BatchDescribeDataTableValueRequestT = Model::BatchDescribeDataTableValueRequest>
  Model::BatchDescribeDataTableValueOutcomeCallable BatchDescribeDataTableValueCallable(
      const BatchDescribeDataTableValueRequestT& request) const {
    return SubmitCallable(&ConnectClient::BatchDescribeDataTableValue, request);
  }
 
  template <typename BatchDescribeDataTableValueRequestT = Model::BatchDescribeDataTableValueRequest>
  void BatchDescribeDataTableValueAsync(const BatchDescribeDataTableValueRequestT& request,
                                        const BatchDescribeDataTableValueResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::BatchDescribeDataTableValue, 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::BatchUpdateDataTableValueOutcome BatchUpdateDataTableValue(const Model::BatchUpdateDataTableValueRequest& request) const;
 
  template <typename BatchUpdateDataTableValueRequestT = Model::BatchUpdateDataTableValueRequest>
  Model::BatchUpdateDataTableValueOutcomeCallable BatchUpdateDataTableValueCallable(
      const BatchUpdateDataTableValueRequestT& request) const {
    return SubmitCallable(&ConnectClient::BatchUpdateDataTableValue, request);
  }
 
  template <typename BatchUpdateDataTableValueRequestT = Model::BatchUpdateDataTableValueRequest>
  void BatchUpdateDataTableValueAsync(const BatchUpdateDataTableValueRequestT& request,
                                      const BatchUpdateDataTableValueResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::BatchUpdateDataTableValue, 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::CreateContactOutcome CreateContact(const Model::CreateContactRequest& request) const;
 
  template <typename CreateContactRequestT = Model::CreateContactRequest>
  Model::CreateContactOutcomeCallable CreateContactCallable(const CreateContactRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateContact, request);
  }
 
  template <typename CreateContactRequestT = Model::CreateContactRequest>
  void CreateContactAsync(const CreateContactRequestT& request, const CreateContactResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateContact, 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::CreateContactFlowModuleAliasOutcome CreateContactFlowModuleAlias(
      const Model::CreateContactFlowModuleAliasRequest& request) const;
 
  template <typename CreateContactFlowModuleAliasRequestT = Model::CreateContactFlowModuleAliasRequest>
  Model::CreateContactFlowModuleAliasOutcomeCallable CreateContactFlowModuleAliasCallable(
      const CreateContactFlowModuleAliasRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateContactFlowModuleAlias, request);
  }
 
  template <typename CreateContactFlowModuleAliasRequestT = Model::CreateContactFlowModuleAliasRequest>
  void CreateContactFlowModuleAliasAsync(const CreateContactFlowModuleAliasRequestT& request,
                                         const CreateContactFlowModuleAliasResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateContactFlowModuleAlias, request, handler, context);
  }
 
  virtual Model::CreateContactFlowModuleVersionOutcome CreateContactFlowModuleVersion(
      const Model::CreateContactFlowModuleVersionRequest& request) const;
 
  template <typename CreateContactFlowModuleVersionRequestT = Model::CreateContactFlowModuleVersionRequest>
  Model::CreateContactFlowModuleVersionOutcomeCallable CreateContactFlowModuleVersionCallable(
      const CreateContactFlowModuleVersionRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateContactFlowModuleVersion, request);
  }
 
  template <typename CreateContactFlowModuleVersionRequestT = Model::CreateContactFlowModuleVersionRequest>
  void CreateContactFlowModuleVersionAsync(const CreateContactFlowModuleVersionRequestT& request,
                                           const CreateContactFlowModuleVersionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateContactFlowModuleVersion, request, handler, context);
  }
 
  virtual Model::CreateContactFlowVersionOutcome CreateContactFlowVersion(const Model::CreateContactFlowVersionRequest& request) const;
 
  template <typename CreateContactFlowVersionRequestT = Model::CreateContactFlowVersionRequest>
  Model::CreateContactFlowVersionOutcomeCallable CreateContactFlowVersionCallable(const CreateContactFlowVersionRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateContactFlowVersion, request);
  }
 
  template <typename CreateContactFlowVersionRequestT = Model::CreateContactFlowVersionRequest>
  void CreateContactFlowVersionAsync(const CreateContactFlowVersionRequestT& request,
                                     const CreateContactFlowVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateContactFlowVersion, request, handler, context);
  }
 
  virtual Model::CreateDataTableOutcome CreateDataTable(const Model::CreateDataTableRequest& request) const;
 
  template <typename CreateDataTableRequestT = Model::CreateDataTableRequest>
  Model::CreateDataTableOutcomeCallable CreateDataTableCallable(const CreateDataTableRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateDataTable, request);
  }
 
  template <typename CreateDataTableRequestT = Model::CreateDataTableRequest>
  void CreateDataTableAsync(const CreateDataTableRequestT& request, const CreateDataTableResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateDataTable, request, handler, context);
  }
 
  virtual Model::CreateDataTableAttributeOutcome CreateDataTableAttribute(const Model::CreateDataTableAttributeRequest& request) const;
 
  template <typename CreateDataTableAttributeRequestT = Model::CreateDataTableAttributeRequest>
  Model::CreateDataTableAttributeOutcomeCallable CreateDataTableAttributeCallable(const CreateDataTableAttributeRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateDataTableAttribute, request);
  }
 
  template <typename CreateDataTableAttributeRequestT = Model::CreateDataTableAttributeRequest>
  void CreateDataTableAttributeAsync(const CreateDataTableAttributeRequestT& request,
                                     const CreateDataTableAttributeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateDataTableAttribute, request, handler, context);
  }
 
  virtual Model::CreateEmailAddressOutcome CreateEmailAddress(const Model::CreateEmailAddressRequest& request) const;
 
  template <typename CreateEmailAddressRequestT = Model::CreateEmailAddressRequest>
  Model::CreateEmailAddressOutcomeCallable CreateEmailAddressCallable(const CreateEmailAddressRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateEmailAddress, request);
  }
 
  template <typename CreateEmailAddressRequestT = Model::CreateEmailAddressRequest>
  void CreateEmailAddressAsync(const CreateEmailAddressRequestT& request, const CreateEmailAddressResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateEmailAddress, 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::CreateHoursOfOperationOverrideOutcome CreateHoursOfOperationOverride(
      const Model::CreateHoursOfOperationOverrideRequest& request) const;
 
  template <typename CreateHoursOfOperationOverrideRequestT = Model::CreateHoursOfOperationOverrideRequest>
  Model::CreateHoursOfOperationOverrideOutcomeCallable CreateHoursOfOperationOverrideCallable(
      const CreateHoursOfOperationOverrideRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateHoursOfOperationOverride, request);
  }
 
  template <typename CreateHoursOfOperationOverrideRequestT = Model::CreateHoursOfOperationOverrideRequest>
  void CreateHoursOfOperationOverrideAsync(const CreateHoursOfOperationOverrideRequestT& request,
                                           const CreateHoursOfOperationOverrideResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateHoursOfOperationOverride, 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::CreateNotificationOutcome CreateNotification(const Model::CreateNotificationRequest& request) const;
 
  template <typename CreateNotificationRequestT = Model::CreateNotificationRequest>
  Model::CreateNotificationOutcomeCallable CreateNotificationCallable(const CreateNotificationRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateNotification, request);
  }
 
  template <typename CreateNotificationRequestT = Model::CreateNotificationRequest>
  void CreateNotificationAsync(const CreateNotificationRequestT& request, const CreateNotificationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateNotification, 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::CreatePushNotificationRegistrationOutcome CreatePushNotificationRegistration(
      const Model::CreatePushNotificationRegistrationRequest& request) const;
 
  template <typename CreatePushNotificationRegistrationRequestT = Model::CreatePushNotificationRegistrationRequest>
  Model::CreatePushNotificationRegistrationOutcomeCallable CreatePushNotificationRegistrationCallable(
      const CreatePushNotificationRegistrationRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreatePushNotificationRegistration, request);
  }
 
  template <typename CreatePushNotificationRegistrationRequestT = Model::CreatePushNotificationRegistrationRequest>
  void CreatePushNotificationRegistrationAsync(const CreatePushNotificationRegistrationRequestT& request,
                                               const CreatePushNotificationRegistrationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreatePushNotificationRegistration, 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::CreateTestCaseOutcome CreateTestCase(const Model::CreateTestCaseRequest& request) const;
 
  template <typename CreateTestCaseRequestT = Model::CreateTestCaseRequest>
  Model::CreateTestCaseOutcomeCallable CreateTestCaseCallable(const CreateTestCaseRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateTestCase, request);
  }
 
  template <typename CreateTestCaseRequestT = Model::CreateTestCaseRequest>
  void CreateTestCaseAsync(const CreateTestCaseRequestT& request, const CreateTestCaseResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateTestCase, 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::CreateWorkspaceOutcome CreateWorkspace(const Model::CreateWorkspaceRequest& request) const;
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  Model::CreateWorkspaceOutcomeCallable CreateWorkspaceCallable(const CreateWorkspaceRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateWorkspace, request);
  }
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  void CreateWorkspaceAsync(const CreateWorkspaceRequestT& request, const CreateWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateWorkspace, request, handler, context);
  }
 
  virtual Model::CreateWorkspacePageOutcome CreateWorkspacePage(const Model::CreateWorkspacePageRequest& request) const;
 
  template <typename CreateWorkspacePageRequestT = Model::CreateWorkspacePageRequest>
  Model::CreateWorkspacePageOutcomeCallable CreateWorkspacePageCallable(const CreateWorkspacePageRequestT& request) const {
    return SubmitCallable(&ConnectClient::CreateWorkspacePage, request);
  }
 
  template <typename CreateWorkspacePageRequestT = Model::CreateWorkspacePageRequest>
  void CreateWorkspacePageAsync(const CreateWorkspacePageRequestT& request, const CreateWorkspacePageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::CreateWorkspacePage, 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::DeleteContactFlowModuleAliasOutcome DeleteContactFlowModuleAlias(
      const Model::DeleteContactFlowModuleAliasRequest& request) const;
 
  template <typename DeleteContactFlowModuleAliasRequestT = Model::DeleteContactFlowModuleAliasRequest>
  Model::DeleteContactFlowModuleAliasOutcomeCallable DeleteContactFlowModuleAliasCallable(
      const DeleteContactFlowModuleAliasRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteContactFlowModuleAlias, request);
  }
 
  template <typename DeleteContactFlowModuleAliasRequestT = Model::DeleteContactFlowModuleAliasRequest>
  void DeleteContactFlowModuleAliasAsync(const DeleteContactFlowModuleAliasRequestT& request,
                                         const DeleteContactFlowModuleAliasResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteContactFlowModuleAlias, request, handler, context);
  }
 
  virtual Model::DeleteContactFlowModuleVersionOutcome DeleteContactFlowModuleVersion(
      const Model::DeleteContactFlowModuleVersionRequest& request) const;
 
  template <typename DeleteContactFlowModuleVersionRequestT = Model::DeleteContactFlowModuleVersionRequest>
  Model::DeleteContactFlowModuleVersionOutcomeCallable DeleteContactFlowModuleVersionCallable(
      const DeleteContactFlowModuleVersionRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteContactFlowModuleVersion, request);
  }
 
  template <typename DeleteContactFlowModuleVersionRequestT = Model::DeleteContactFlowModuleVersionRequest>
  void DeleteContactFlowModuleVersionAsync(const DeleteContactFlowModuleVersionRequestT& request,
                                           const DeleteContactFlowModuleVersionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteContactFlowModuleVersion, request, handler, context);
  }
 
  virtual Model::DeleteContactFlowVersionOutcome DeleteContactFlowVersion(const Model::DeleteContactFlowVersionRequest& request) const;
 
  template <typename DeleteContactFlowVersionRequestT = Model::DeleteContactFlowVersionRequest>
  Model::DeleteContactFlowVersionOutcomeCallable DeleteContactFlowVersionCallable(const DeleteContactFlowVersionRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteContactFlowVersion, request);
  }
 
  template <typename DeleteContactFlowVersionRequestT = Model::DeleteContactFlowVersionRequest>
  void DeleteContactFlowVersionAsync(const DeleteContactFlowVersionRequestT& request,
                                     const DeleteContactFlowVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteContactFlowVersion, request, handler, context);
  }
 
  virtual Model::DeleteDataTableOutcome DeleteDataTable(const Model::DeleteDataTableRequest& request) const;
 
  template <typename DeleteDataTableRequestT = Model::DeleteDataTableRequest>
  Model::DeleteDataTableOutcomeCallable DeleteDataTableCallable(const DeleteDataTableRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteDataTable, request);
  }
 
  template <typename DeleteDataTableRequestT = Model::DeleteDataTableRequest>
  void DeleteDataTableAsync(const DeleteDataTableRequestT& request, const DeleteDataTableResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteDataTable, request, handler, context);
  }
 
  virtual Model::DeleteDataTableAttributeOutcome DeleteDataTableAttribute(const Model::DeleteDataTableAttributeRequest& request) const;
 
  template <typename DeleteDataTableAttributeRequestT = Model::DeleteDataTableAttributeRequest>
  Model::DeleteDataTableAttributeOutcomeCallable DeleteDataTableAttributeCallable(const DeleteDataTableAttributeRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteDataTableAttribute, request);
  }
 
  template <typename DeleteDataTableAttributeRequestT = Model::DeleteDataTableAttributeRequest>
  void DeleteDataTableAttributeAsync(const DeleteDataTableAttributeRequestT& request,
                                     const DeleteDataTableAttributeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteDataTableAttribute, request, handler, context);
  }
 
  virtual Model::DeleteEmailAddressOutcome DeleteEmailAddress(const Model::DeleteEmailAddressRequest& request) const;
 
  template <typename DeleteEmailAddressRequestT = Model::DeleteEmailAddressRequest>
  Model::DeleteEmailAddressOutcomeCallable DeleteEmailAddressCallable(const DeleteEmailAddressRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteEmailAddress, request);
  }
 
  template <typename DeleteEmailAddressRequestT = Model::DeleteEmailAddressRequest>
  void DeleteEmailAddressAsync(const DeleteEmailAddressRequestT& request, const DeleteEmailAddressResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteEmailAddress, 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::DeleteHoursOfOperationOverrideOutcome DeleteHoursOfOperationOverride(
      const Model::DeleteHoursOfOperationOverrideRequest& request) const;
 
  template <typename DeleteHoursOfOperationOverrideRequestT = Model::DeleteHoursOfOperationOverrideRequest>
  Model::DeleteHoursOfOperationOverrideOutcomeCallable DeleteHoursOfOperationOverrideCallable(
      const DeleteHoursOfOperationOverrideRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteHoursOfOperationOverride, request);
  }
 
  template <typename DeleteHoursOfOperationOverrideRequestT = Model::DeleteHoursOfOperationOverrideRequest>
  void DeleteHoursOfOperationOverrideAsync(const DeleteHoursOfOperationOverrideRequestT& request,
                                           const DeleteHoursOfOperationOverrideResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteHoursOfOperationOverride, 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::DeleteNotificationOutcome DeleteNotification(const Model::DeleteNotificationRequest& request) const;
 
  template <typename DeleteNotificationRequestT = Model::DeleteNotificationRequest>
  Model::DeleteNotificationOutcomeCallable DeleteNotificationCallable(const DeleteNotificationRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteNotification, request);
  }
 
  template <typename DeleteNotificationRequestT = Model::DeleteNotificationRequest>
  void DeleteNotificationAsync(const DeleteNotificationRequestT& request, const DeleteNotificationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteNotification, 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::DeletePushNotificationRegistrationOutcome DeletePushNotificationRegistration(
      const Model::DeletePushNotificationRegistrationRequest& request) const;
 
  template <typename DeletePushNotificationRegistrationRequestT = Model::DeletePushNotificationRegistrationRequest>
  Model::DeletePushNotificationRegistrationOutcomeCallable DeletePushNotificationRegistrationCallable(
      const DeletePushNotificationRegistrationRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeletePushNotificationRegistration, request);
  }
 
  template <typename DeletePushNotificationRegistrationRequestT = Model::DeletePushNotificationRegistrationRequest>
  void DeletePushNotificationRegistrationAsync(const DeletePushNotificationRegistrationRequestT& request,
                                               const DeletePushNotificationRegistrationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeletePushNotificationRegistration, 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::DeleteTestCaseOutcome DeleteTestCase(const Model::DeleteTestCaseRequest& request) const;
 
  template <typename DeleteTestCaseRequestT = Model::DeleteTestCaseRequest>
  Model::DeleteTestCaseOutcomeCallable DeleteTestCaseCallable(const DeleteTestCaseRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteTestCase, request);
  }
 
  template <typename DeleteTestCaseRequestT = Model::DeleteTestCaseRequest>
  void DeleteTestCaseAsync(const DeleteTestCaseRequestT& request, const DeleteTestCaseResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteTestCase, 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::DeleteWorkspaceOutcome DeleteWorkspace(const Model::DeleteWorkspaceRequest& request) const;
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  Model::DeleteWorkspaceOutcomeCallable DeleteWorkspaceCallable(const DeleteWorkspaceRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteWorkspace, request);
  }
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  void DeleteWorkspaceAsync(const DeleteWorkspaceRequestT& request, const DeleteWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteWorkspace, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceMediaOutcome DeleteWorkspaceMedia(const Model::DeleteWorkspaceMediaRequest& request) const;
 
  template <typename DeleteWorkspaceMediaRequestT = Model::DeleteWorkspaceMediaRequest>
  Model::DeleteWorkspaceMediaOutcomeCallable DeleteWorkspaceMediaCallable(const DeleteWorkspaceMediaRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteWorkspaceMedia, request);
  }
 
  template <typename DeleteWorkspaceMediaRequestT = Model::DeleteWorkspaceMediaRequest>
  void DeleteWorkspaceMediaAsync(const DeleteWorkspaceMediaRequestT& request, const DeleteWorkspaceMediaResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteWorkspaceMedia, request, handler, context);
  }
 
  virtual Model::DeleteWorkspacePageOutcome DeleteWorkspacePage(const Model::DeleteWorkspacePageRequest& request) const;
 
  template <typename DeleteWorkspacePageRequestT = Model::DeleteWorkspacePageRequest>
  Model::DeleteWorkspacePageOutcomeCallable DeleteWorkspacePageCallable(const DeleteWorkspacePageRequestT& request) const {
    return SubmitCallable(&ConnectClient::DeleteWorkspacePage, request);
  }
 
  template <typename DeleteWorkspacePageRequestT = Model::DeleteWorkspacePageRequest>
  void DeleteWorkspacePageAsync(const DeleteWorkspacePageRequestT& request, const DeleteWorkspacePageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DeleteWorkspacePage, 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::DescribeContactFlowModuleAliasOutcome DescribeContactFlowModuleAlias(
      const Model::DescribeContactFlowModuleAliasRequest& request) const;
 
  template <typename DescribeContactFlowModuleAliasRequestT = Model::DescribeContactFlowModuleAliasRequest>
  Model::DescribeContactFlowModuleAliasOutcomeCallable DescribeContactFlowModuleAliasCallable(
      const DescribeContactFlowModuleAliasRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeContactFlowModuleAlias, request);
  }
 
  template <typename DescribeContactFlowModuleAliasRequestT = Model::DescribeContactFlowModuleAliasRequest>
  void DescribeContactFlowModuleAliasAsync(const DescribeContactFlowModuleAliasRequestT& request,
                                           const DescribeContactFlowModuleAliasResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeContactFlowModuleAlias, request, handler, context);
  }
 
  virtual Model::DescribeDataTableOutcome DescribeDataTable(const Model::DescribeDataTableRequest& request) const;
 
  template <typename DescribeDataTableRequestT = Model::DescribeDataTableRequest>
  Model::DescribeDataTableOutcomeCallable DescribeDataTableCallable(const DescribeDataTableRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeDataTable, request);
  }
 
  template <typename DescribeDataTableRequestT = Model::DescribeDataTableRequest>
  void DescribeDataTableAsync(const DescribeDataTableRequestT& request, const DescribeDataTableResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeDataTable, request, handler, context);
  }
 
  virtual Model::DescribeDataTableAttributeOutcome DescribeDataTableAttribute(
      const Model::DescribeDataTableAttributeRequest& request) const;
 
  template <typename DescribeDataTableAttributeRequestT = Model::DescribeDataTableAttributeRequest>
  Model::DescribeDataTableAttributeOutcomeCallable DescribeDataTableAttributeCallable(
      const DescribeDataTableAttributeRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeDataTableAttribute, request);
  }
 
  template <typename DescribeDataTableAttributeRequestT = Model::DescribeDataTableAttributeRequest>
  void DescribeDataTableAttributeAsync(const DescribeDataTableAttributeRequestT& request,
                                       const DescribeDataTableAttributeResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeDataTableAttribute, request, handler, context);
  }
 
  virtual Model::DescribeEmailAddressOutcome DescribeEmailAddress(const Model::DescribeEmailAddressRequest& request) const;
 
  template <typename DescribeEmailAddressRequestT = Model::DescribeEmailAddressRequest>
  Model::DescribeEmailAddressOutcomeCallable DescribeEmailAddressCallable(const DescribeEmailAddressRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeEmailAddress, request);
  }
 
  template <typename DescribeEmailAddressRequestT = Model::DescribeEmailAddressRequest>
  void DescribeEmailAddressAsync(const DescribeEmailAddressRequestT& request, const DescribeEmailAddressResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeEmailAddress, 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::DescribeHoursOfOperationOverrideOutcome DescribeHoursOfOperationOverride(
      const Model::DescribeHoursOfOperationOverrideRequest& request) const;
 
  template <typename DescribeHoursOfOperationOverrideRequestT = Model::DescribeHoursOfOperationOverrideRequest>
  Model::DescribeHoursOfOperationOverrideOutcomeCallable DescribeHoursOfOperationOverrideCallable(
      const DescribeHoursOfOperationOverrideRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeHoursOfOperationOverride, request);
  }
 
  template <typename DescribeHoursOfOperationOverrideRequestT = Model::DescribeHoursOfOperationOverrideRequest>
  void DescribeHoursOfOperationOverrideAsync(const DescribeHoursOfOperationOverrideRequestT& request,
                                             const DescribeHoursOfOperationOverrideResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeHoursOfOperationOverride, 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::DescribeNotificationOutcome DescribeNotification(const Model::DescribeNotificationRequest& request) const;
 
  template <typename DescribeNotificationRequestT = Model::DescribeNotificationRequest>
  Model::DescribeNotificationOutcomeCallable DescribeNotificationCallable(const DescribeNotificationRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeNotification, request);
  }
 
  template <typename DescribeNotificationRequestT = Model::DescribeNotificationRequest>
  void DescribeNotificationAsync(const DescribeNotificationRequestT& request, const DescribeNotificationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeNotification, 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::DescribeTestCaseOutcome DescribeTestCase(const Model::DescribeTestCaseRequest& request) const;
 
  template <typename DescribeTestCaseRequestT = Model::DescribeTestCaseRequest>
  Model::DescribeTestCaseOutcomeCallable DescribeTestCaseCallable(const DescribeTestCaseRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeTestCase, request);
  }
 
  template <typename DescribeTestCaseRequestT = Model::DescribeTestCaseRequest>
  void DescribeTestCaseAsync(const DescribeTestCaseRequestT& request, const DescribeTestCaseResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeTestCase, 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::DescribeWorkspaceOutcome DescribeWorkspace(const Model::DescribeWorkspaceRequest& request) const;
 
  template <typename DescribeWorkspaceRequestT = Model::DescribeWorkspaceRequest>
  Model::DescribeWorkspaceOutcomeCallable DescribeWorkspaceCallable(const DescribeWorkspaceRequestT& request) const {
    return SubmitCallable(&ConnectClient::DescribeWorkspace, request);
  }
 
  template <typename DescribeWorkspaceRequestT = Model::DescribeWorkspaceRequest>
  void DescribeWorkspaceAsync(const DescribeWorkspaceRequestT& request, const DescribeWorkspaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DescribeWorkspace, 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::DisassociateEmailAddressAliasOutcome DisassociateEmailAddressAlias(
      const Model::DisassociateEmailAddressAliasRequest& request) const;
 
  template <typename DisassociateEmailAddressAliasRequestT = Model::DisassociateEmailAddressAliasRequest>
  Model::DisassociateEmailAddressAliasOutcomeCallable DisassociateEmailAddressAliasCallable(
      const DisassociateEmailAddressAliasRequestT& request) const {
    return SubmitCallable(&ConnectClient::DisassociateEmailAddressAlias, request);
  }
 
  template <typename DisassociateEmailAddressAliasRequestT = Model::DisassociateEmailAddressAliasRequest>
  void DisassociateEmailAddressAliasAsync(const DisassociateEmailAddressAliasRequestT& request,
                                          const DisassociateEmailAddressAliasResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DisassociateEmailAddressAlias, 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::DisassociateHoursOfOperationsOutcome DisassociateHoursOfOperations(
      const Model::DisassociateHoursOfOperationsRequest& request) const;
 
  template <typename DisassociateHoursOfOperationsRequestT = Model::DisassociateHoursOfOperationsRequest>
  Model::DisassociateHoursOfOperationsOutcomeCallable DisassociateHoursOfOperationsCallable(
      const DisassociateHoursOfOperationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::DisassociateHoursOfOperations, request);
  }
 
  template <typename DisassociateHoursOfOperationsRequestT = Model::DisassociateHoursOfOperationsRequest>
  void DisassociateHoursOfOperationsAsync(const DisassociateHoursOfOperationsRequestT& request,
                                          const DisassociateHoursOfOperationsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DisassociateHoursOfOperations, 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::DisassociateQueueEmailAddressesOutcome DisassociateQueueEmailAddresses(
      const Model::DisassociateQueueEmailAddressesRequest& request) const;
 
  template <typename DisassociateQueueEmailAddressesRequestT = Model::DisassociateQueueEmailAddressesRequest>
  Model::DisassociateQueueEmailAddressesOutcomeCallable DisassociateQueueEmailAddressesCallable(
      const DisassociateQueueEmailAddressesRequestT& request) const {
    return SubmitCallable(&ConnectClient::DisassociateQueueEmailAddresses, request);
  }
 
  template <typename DisassociateQueueEmailAddressesRequestT = Model::DisassociateQueueEmailAddressesRequest>
  void DisassociateQueueEmailAddressesAsync(const DisassociateQueueEmailAddressesRequestT& request,
                                            const DisassociateQueueEmailAddressesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DisassociateQueueEmailAddresses, 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::DisassociateSecurityProfilesOutcome DisassociateSecurityProfiles(
      const Model::DisassociateSecurityProfilesRequest& request) const;
 
  template <typename DisassociateSecurityProfilesRequestT = Model::DisassociateSecurityProfilesRequest>
  Model::DisassociateSecurityProfilesOutcomeCallable DisassociateSecurityProfilesCallable(
      const DisassociateSecurityProfilesRequestT& request) const {
    return SubmitCallable(&ConnectClient::DisassociateSecurityProfiles, request);
  }
 
  template <typename DisassociateSecurityProfilesRequestT = Model::DisassociateSecurityProfilesRequest>
  void DisassociateSecurityProfilesAsync(const DisassociateSecurityProfilesRequestT& request,
                                         const DisassociateSecurityProfilesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DisassociateSecurityProfiles, 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::DisassociateWorkspaceOutcome DisassociateWorkspace(const Model::DisassociateWorkspaceRequest& request) const;
 
  template <typename DisassociateWorkspaceRequestT = Model::DisassociateWorkspaceRequest>
  Model::DisassociateWorkspaceOutcomeCallable DisassociateWorkspaceCallable(const DisassociateWorkspaceRequestT& request) const {
    return SubmitCallable(&ConnectClient::DisassociateWorkspace, request);
  }
 
  template <typename DisassociateWorkspaceRequestT = Model::DisassociateWorkspaceRequest>
  void DisassociateWorkspaceAsync(const DisassociateWorkspaceRequestT& request, const DisassociateWorkspaceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::DisassociateWorkspace, 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::EvaluateDataTableValuesOutcome EvaluateDataTableValues(const Model::EvaluateDataTableValuesRequest& request) const;
 
  template <typename EvaluateDataTableValuesRequestT = Model::EvaluateDataTableValuesRequest>
  Model::EvaluateDataTableValuesOutcomeCallable EvaluateDataTableValuesCallable(const EvaluateDataTableValuesRequestT& request) const {
    return SubmitCallable(&ConnectClient::EvaluateDataTableValues, request);
  }
 
  template <typename EvaluateDataTableValuesRequestT = Model::EvaluateDataTableValuesRequest>
  void EvaluateDataTableValuesAsync(const EvaluateDataTableValuesRequestT& request,
                                    const EvaluateDataTableValuesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::EvaluateDataTableValues, 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::GetContactMetricsOutcome GetContactMetrics(const Model::GetContactMetricsRequest& request) const;
 
  template <typename GetContactMetricsRequestT = Model::GetContactMetricsRequest>
  Model::GetContactMetricsOutcomeCallable GetContactMetricsCallable(const GetContactMetricsRequestT& request) const {
    return SubmitCallable(&ConnectClient::GetContactMetrics, request);
  }
 
  template <typename GetContactMetricsRequestT = Model::GetContactMetricsRequest>
  void GetContactMetricsAsync(const GetContactMetricsRequestT& request, const GetContactMetricsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::GetContactMetrics, 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::GetEffectiveHoursOfOperationsOutcome GetEffectiveHoursOfOperations(
      const Model::GetEffectiveHoursOfOperationsRequest& request) const;
 
  template <typename GetEffectiveHoursOfOperationsRequestT = Model::GetEffectiveHoursOfOperationsRequest>
  Model::GetEffectiveHoursOfOperationsOutcomeCallable GetEffectiveHoursOfOperationsCallable(
      const GetEffectiveHoursOfOperationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::GetEffectiveHoursOfOperations, request);
  }
 
  template <typename GetEffectiveHoursOfOperationsRequestT = Model::GetEffectiveHoursOfOperationsRequest>
  void GetEffectiveHoursOfOperationsAsync(const GetEffectiveHoursOfOperationsRequestT& request,
                                          const GetEffectiveHoursOfOperationsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::GetEffectiveHoursOfOperations, 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::GetTestCaseExecutionSummaryOutcome GetTestCaseExecutionSummary(
      const Model::GetTestCaseExecutionSummaryRequest& request) const;
 
  template <typename GetTestCaseExecutionSummaryRequestT = Model::GetTestCaseExecutionSummaryRequest>
  Model::GetTestCaseExecutionSummaryOutcomeCallable GetTestCaseExecutionSummaryCallable(
      const GetTestCaseExecutionSummaryRequestT& request) const {
    return SubmitCallable(&ConnectClient::GetTestCaseExecutionSummary, request);
  }
 
  template <typename GetTestCaseExecutionSummaryRequestT = Model::GetTestCaseExecutionSummaryRequest>
  void GetTestCaseExecutionSummaryAsync(const GetTestCaseExecutionSummaryRequestT& request,
                                        const GetTestCaseExecutionSummaryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::GetTestCaseExecutionSummary, 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::ImportWorkspaceMediaOutcome ImportWorkspaceMedia(const Model::ImportWorkspaceMediaRequest& request) const;
 
  template <typename ImportWorkspaceMediaRequestT = Model::ImportWorkspaceMediaRequest>
  Model::ImportWorkspaceMediaOutcomeCallable ImportWorkspaceMediaCallable(const ImportWorkspaceMediaRequestT& request) const {
    return SubmitCallable(&ConnectClient::ImportWorkspaceMedia, request);
  }
 
  template <typename ImportWorkspaceMediaRequestT = Model::ImportWorkspaceMediaRequest>
  void ImportWorkspaceMediaAsync(const ImportWorkspaceMediaRequestT& request, const ImportWorkspaceMediaResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ImportWorkspaceMedia, 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::ListAnalyticsDataLakeDataSetsOutcome ListAnalyticsDataLakeDataSets(
      const Model::ListAnalyticsDataLakeDataSetsRequest& request) const;
 
  template <typename ListAnalyticsDataLakeDataSetsRequestT = Model::ListAnalyticsDataLakeDataSetsRequest>
  Model::ListAnalyticsDataLakeDataSetsOutcomeCallable ListAnalyticsDataLakeDataSetsCallable(
      const ListAnalyticsDataLakeDataSetsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListAnalyticsDataLakeDataSets, request);
  }
 
  template <typename ListAnalyticsDataLakeDataSetsRequestT = Model::ListAnalyticsDataLakeDataSetsRequest>
  void ListAnalyticsDataLakeDataSetsAsync(const ListAnalyticsDataLakeDataSetsRequestT& request,
                                          const ListAnalyticsDataLakeDataSetsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListAnalyticsDataLakeDataSets, 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::ListAssociatedContactsOutcome ListAssociatedContacts(const Model::ListAssociatedContactsRequest& request) const;
 
  template <typename ListAssociatedContactsRequestT = Model::ListAssociatedContactsRequest>
  Model::ListAssociatedContactsOutcomeCallable ListAssociatedContactsCallable(const ListAssociatedContactsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListAssociatedContacts, request);
  }
 
  template <typename ListAssociatedContactsRequestT = Model::ListAssociatedContactsRequest>
  void ListAssociatedContactsAsync(const ListAssociatedContactsRequestT& request,
                                   const ListAssociatedContactsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListAssociatedContacts, 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::ListChildHoursOfOperationsOutcome ListChildHoursOfOperations(
      const Model::ListChildHoursOfOperationsRequest& request) const;
 
  template <typename ListChildHoursOfOperationsRequestT = Model::ListChildHoursOfOperationsRequest>
  Model::ListChildHoursOfOperationsOutcomeCallable ListChildHoursOfOperationsCallable(
      const ListChildHoursOfOperationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListChildHoursOfOperations, request);
  }
 
  template <typename ListChildHoursOfOperationsRequestT = Model::ListChildHoursOfOperationsRequest>
  void ListChildHoursOfOperationsAsync(const ListChildHoursOfOperationsRequestT& request,
                                       const ListChildHoursOfOperationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListChildHoursOfOperations, 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::ListContactFlowModuleAliasesOutcome ListContactFlowModuleAliases(
      const Model::ListContactFlowModuleAliasesRequest& request) const;
 
  template <typename ListContactFlowModuleAliasesRequestT = Model::ListContactFlowModuleAliasesRequest>
  Model::ListContactFlowModuleAliasesOutcomeCallable ListContactFlowModuleAliasesCallable(
      const ListContactFlowModuleAliasesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListContactFlowModuleAliases, request);
  }
 
  template <typename ListContactFlowModuleAliasesRequestT = Model::ListContactFlowModuleAliasesRequest>
  void ListContactFlowModuleAliasesAsync(const ListContactFlowModuleAliasesRequestT& request,
                                         const ListContactFlowModuleAliasesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListContactFlowModuleAliases, request, handler, context);
  }
 
  virtual Model::ListContactFlowModuleVersionsOutcome ListContactFlowModuleVersions(
      const Model::ListContactFlowModuleVersionsRequest& request) const;
 
  template <typename ListContactFlowModuleVersionsRequestT = Model::ListContactFlowModuleVersionsRequest>
  Model::ListContactFlowModuleVersionsOutcomeCallable ListContactFlowModuleVersionsCallable(
      const ListContactFlowModuleVersionsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListContactFlowModuleVersions, request);
  }
 
  template <typename ListContactFlowModuleVersionsRequestT = Model::ListContactFlowModuleVersionsRequest>
  void ListContactFlowModuleVersionsAsync(const ListContactFlowModuleVersionsRequestT& request,
                                          const ListContactFlowModuleVersionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListContactFlowModuleVersions, 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::ListContactFlowVersionsOutcome ListContactFlowVersions(const Model::ListContactFlowVersionsRequest& request) const;
 
  template <typename ListContactFlowVersionsRequestT = Model::ListContactFlowVersionsRequest>
  Model::ListContactFlowVersionsOutcomeCallable ListContactFlowVersionsCallable(const ListContactFlowVersionsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListContactFlowVersions, request);
  }
 
  template <typename ListContactFlowVersionsRequestT = Model::ListContactFlowVersionsRequest>
  void ListContactFlowVersionsAsync(const ListContactFlowVersionsRequestT& request,
                                    const ListContactFlowVersionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListContactFlowVersions, 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::ListDataTableAttributesOutcome ListDataTableAttributes(const Model::ListDataTableAttributesRequest& request) const;
 
  template <typename ListDataTableAttributesRequestT = Model::ListDataTableAttributesRequest>
  Model::ListDataTableAttributesOutcomeCallable ListDataTableAttributesCallable(const ListDataTableAttributesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListDataTableAttributes, request);
  }
 
  template <typename ListDataTableAttributesRequestT = Model::ListDataTableAttributesRequest>
  void ListDataTableAttributesAsync(const ListDataTableAttributesRequestT& request,
                                    const ListDataTableAttributesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListDataTableAttributes, request, handler, context);
  }
 
  virtual Model::ListDataTablePrimaryValuesOutcome ListDataTablePrimaryValues(
      const Model::ListDataTablePrimaryValuesRequest& request) const;
 
  template <typename ListDataTablePrimaryValuesRequestT = Model::ListDataTablePrimaryValuesRequest>
  Model::ListDataTablePrimaryValuesOutcomeCallable ListDataTablePrimaryValuesCallable(
      const ListDataTablePrimaryValuesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListDataTablePrimaryValues, request);
  }
 
  template <typename ListDataTablePrimaryValuesRequestT = Model::ListDataTablePrimaryValuesRequest>
  void ListDataTablePrimaryValuesAsync(const ListDataTablePrimaryValuesRequestT& request,
                                       const ListDataTablePrimaryValuesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListDataTablePrimaryValues, request, handler, context);
  }
 
  virtual Model::ListDataTableValuesOutcome ListDataTableValues(const Model::ListDataTableValuesRequest& request) const;
 
  template <typename ListDataTableValuesRequestT = Model::ListDataTableValuesRequest>
  Model::ListDataTableValuesOutcomeCallable ListDataTableValuesCallable(const ListDataTableValuesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListDataTableValues, request);
  }
 
  template <typename ListDataTableValuesRequestT = Model::ListDataTableValuesRequest>
  void ListDataTableValuesAsync(const ListDataTableValuesRequestT& request, const ListDataTableValuesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListDataTableValues, request, handler, context);
  }
 
  virtual Model::ListDataTablesOutcome ListDataTables(const Model::ListDataTablesRequest& request) const;
 
  template <typename ListDataTablesRequestT = Model::ListDataTablesRequest>
  Model::ListDataTablesOutcomeCallable ListDataTablesCallable(const ListDataTablesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListDataTables, request);
  }
 
  template <typename ListDataTablesRequestT = Model::ListDataTablesRequest>
  void ListDataTablesAsync(const ListDataTablesRequestT& request, const ListDataTablesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListDataTables, 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::ListEntitySecurityProfilesOutcome ListEntitySecurityProfiles(
      const Model::ListEntitySecurityProfilesRequest& request) const;
 
  template <typename ListEntitySecurityProfilesRequestT = Model::ListEntitySecurityProfilesRequest>
  Model::ListEntitySecurityProfilesOutcomeCallable ListEntitySecurityProfilesCallable(
      const ListEntitySecurityProfilesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListEntitySecurityProfiles, request);
  }
 
  template <typename ListEntitySecurityProfilesRequestT = Model::ListEntitySecurityProfilesRequest>
  void ListEntitySecurityProfilesAsync(const ListEntitySecurityProfilesRequestT& request,
                                       const ListEntitySecurityProfilesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListEntitySecurityProfiles, 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::ListHoursOfOperationOverridesOutcome ListHoursOfOperationOverrides(
      const Model::ListHoursOfOperationOverridesRequest& request) const;
 
  template <typename ListHoursOfOperationOverridesRequestT = Model::ListHoursOfOperationOverridesRequest>
  Model::ListHoursOfOperationOverridesOutcomeCallable ListHoursOfOperationOverridesCallable(
      const ListHoursOfOperationOverridesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListHoursOfOperationOverrides, request);
  }
 
  template <typename ListHoursOfOperationOverridesRequestT = Model::ListHoursOfOperationOverridesRequest>
  void ListHoursOfOperationOverridesAsync(const ListHoursOfOperationOverridesRequestT& request,
                                          const ListHoursOfOperationOverridesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListHoursOfOperationOverrides, 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::ListNotificationsOutcome ListNotifications(const Model::ListNotificationsRequest& request) const;
 
  template <typename ListNotificationsRequestT = Model::ListNotificationsRequest>
  Model::ListNotificationsOutcomeCallable ListNotificationsCallable(const ListNotificationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListNotifications, request);
  }
 
  template <typename ListNotificationsRequestT = Model::ListNotificationsRequest>
  void ListNotificationsAsync(const ListNotificationsRequestT& request, const ListNotificationsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListNotifications, 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::ListQueueEmailAddressesOutcome ListQueueEmailAddresses(const Model::ListQueueEmailAddressesRequest& request) const;
 
  template <typename ListQueueEmailAddressesRequestT = Model::ListQueueEmailAddressesRequest>
  Model::ListQueueEmailAddressesOutcomeCallable ListQueueEmailAddressesCallable(const ListQueueEmailAddressesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListQueueEmailAddresses, request);
  }
 
  template <typename ListQueueEmailAddressesRequestT = Model::ListQueueEmailAddressesRequest>
  void ListQueueEmailAddressesAsync(const ListQueueEmailAddressesRequestT& request,
                                    const ListQueueEmailAddressesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListQueueEmailAddresses, 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::ListRoutingProfileManualAssignmentQueuesOutcome ListRoutingProfileManualAssignmentQueues(
      const Model::ListRoutingProfileManualAssignmentQueuesRequest& request) const;
 
  template <typename ListRoutingProfileManualAssignmentQueuesRequestT = Model::ListRoutingProfileManualAssignmentQueuesRequest>
  Model::ListRoutingProfileManualAssignmentQueuesOutcomeCallable ListRoutingProfileManualAssignmentQueuesCallable(
      const ListRoutingProfileManualAssignmentQueuesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListRoutingProfileManualAssignmentQueues, request);
  }
 
  template <typename ListRoutingProfileManualAssignmentQueuesRequestT = Model::ListRoutingProfileManualAssignmentQueuesRequest>
  void ListRoutingProfileManualAssignmentQueuesAsync(
      const ListRoutingProfileManualAssignmentQueuesRequestT& request,
      const ListRoutingProfileManualAssignmentQueuesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListRoutingProfileManualAssignmentQueues, 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::ListSecurityProfileFlowModulesOutcome ListSecurityProfileFlowModules(
      const Model::ListSecurityProfileFlowModulesRequest& request) const;
 
  template <typename ListSecurityProfileFlowModulesRequestT = Model::ListSecurityProfileFlowModulesRequest>
  Model::ListSecurityProfileFlowModulesOutcomeCallable ListSecurityProfileFlowModulesCallable(
      const ListSecurityProfileFlowModulesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListSecurityProfileFlowModules, request);
  }
 
  template <typename ListSecurityProfileFlowModulesRequestT = Model::ListSecurityProfileFlowModulesRequest>
  void ListSecurityProfileFlowModulesAsync(const ListSecurityProfileFlowModulesRequestT& request,
                                           const ListSecurityProfileFlowModulesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListSecurityProfileFlowModules, 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::ListTestCaseExecutionRecordsOutcome ListTestCaseExecutionRecords(
      const Model::ListTestCaseExecutionRecordsRequest& request) const;
 
  template <typename ListTestCaseExecutionRecordsRequestT = Model::ListTestCaseExecutionRecordsRequest>
  Model::ListTestCaseExecutionRecordsOutcomeCallable ListTestCaseExecutionRecordsCallable(
      const ListTestCaseExecutionRecordsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListTestCaseExecutionRecords, request);
  }
 
  template <typename ListTestCaseExecutionRecordsRequestT = Model::ListTestCaseExecutionRecordsRequest>
  void ListTestCaseExecutionRecordsAsync(const ListTestCaseExecutionRecordsRequestT& request,
                                         const ListTestCaseExecutionRecordsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListTestCaseExecutionRecords, request, handler, context);
  }
 
  virtual Model::ListTestCaseExecutionsOutcome ListTestCaseExecutions(const Model::ListTestCaseExecutionsRequest& request) const;
 
  template <typename ListTestCaseExecutionsRequestT = Model::ListTestCaseExecutionsRequest>
  Model::ListTestCaseExecutionsOutcomeCallable ListTestCaseExecutionsCallable(const ListTestCaseExecutionsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListTestCaseExecutions, request);
  }
 
  template <typename ListTestCaseExecutionsRequestT = Model::ListTestCaseExecutionsRequest>
  void ListTestCaseExecutionsAsync(const ListTestCaseExecutionsRequestT& request,
                                   const ListTestCaseExecutionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListTestCaseExecutions, request, handler, context);
  }
 
  virtual Model::ListTestCasesOutcome ListTestCases(const Model::ListTestCasesRequest& request) const;
 
  template <typename ListTestCasesRequestT = Model::ListTestCasesRequest>
  Model::ListTestCasesOutcomeCallable ListTestCasesCallable(const ListTestCasesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListTestCases, request);
  }
 
  template <typename ListTestCasesRequestT = Model::ListTestCasesRequest>
  void ListTestCasesAsync(const ListTestCasesRequestT& request, const ListTestCasesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListTestCases, 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::ListUserNotificationsOutcome ListUserNotifications(const Model::ListUserNotificationsRequest& request) const;
 
  template <typename ListUserNotificationsRequestT = Model::ListUserNotificationsRequest>
  Model::ListUserNotificationsOutcomeCallable ListUserNotificationsCallable(const ListUserNotificationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListUserNotifications, request);
  }
 
  template <typename ListUserNotificationsRequestT = Model::ListUserNotificationsRequest>
  void ListUserNotificationsAsync(const ListUserNotificationsRequestT& request, const ListUserNotificationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListUserNotifications, 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::ListWorkspaceMediaOutcome ListWorkspaceMedia(const Model::ListWorkspaceMediaRequest& request) const;
 
  template <typename ListWorkspaceMediaRequestT = Model::ListWorkspaceMediaRequest>
  Model::ListWorkspaceMediaOutcomeCallable ListWorkspaceMediaCallable(const ListWorkspaceMediaRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListWorkspaceMedia, request);
  }
 
  template <typename ListWorkspaceMediaRequestT = Model::ListWorkspaceMediaRequest>
  void ListWorkspaceMediaAsync(const ListWorkspaceMediaRequestT& request, const ListWorkspaceMediaResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListWorkspaceMedia, request, handler, context);
  }
 
  virtual Model::ListWorkspacePagesOutcome ListWorkspacePages(const Model::ListWorkspacePagesRequest& request) const;
 
  template <typename ListWorkspacePagesRequestT = Model::ListWorkspacePagesRequest>
  Model::ListWorkspacePagesOutcomeCallable ListWorkspacePagesCallable(const ListWorkspacePagesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListWorkspacePages, request);
  }
 
  template <typename ListWorkspacePagesRequestT = Model::ListWorkspacePagesRequest>
  void ListWorkspacePagesAsync(const ListWorkspacePagesRequestT& request, const ListWorkspacePagesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListWorkspacePages, request, handler, context);
  }
 
  virtual Model::ListWorkspacesOutcome ListWorkspaces(const Model::ListWorkspacesRequest& request) const;
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  Model::ListWorkspacesOutcomeCallable ListWorkspacesCallable(const ListWorkspacesRequestT& request) const {
    return SubmitCallable(&ConnectClient::ListWorkspaces, request);
  }
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  void ListWorkspacesAsync(const ListWorkspacesRequestT& request, const ListWorkspacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::ListWorkspaces, 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::SearchContactEvaluationsOutcome SearchContactEvaluations(const Model::SearchContactEvaluationsRequest& request) const;
 
  template <typename SearchContactEvaluationsRequestT = Model::SearchContactEvaluationsRequest>
  Model::SearchContactEvaluationsOutcomeCallable SearchContactEvaluationsCallable(const SearchContactEvaluationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchContactEvaluations, request);
  }
 
  template <typename SearchContactEvaluationsRequestT = Model::SearchContactEvaluationsRequest>
  void SearchContactEvaluationsAsync(const SearchContactEvaluationsRequestT& request,
                                     const SearchContactEvaluationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchContactEvaluations, 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::SearchDataTablesOutcome SearchDataTables(const Model::SearchDataTablesRequest& request) const;
 
  template <typename SearchDataTablesRequestT = Model::SearchDataTablesRequest>
  Model::SearchDataTablesOutcomeCallable SearchDataTablesCallable(const SearchDataTablesRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchDataTables, request);
  }
 
  template <typename SearchDataTablesRequestT = Model::SearchDataTablesRequest>
  void SearchDataTablesAsync(const SearchDataTablesRequestT& request, const SearchDataTablesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchDataTables, request, handler, context);
  }
 
  virtual Model::SearchEmailAddressesOutcome SearchEmailAddresses(const Model::SearchEmailAddressesRequest& request) const;
 
  template <typename SearchEmailAddressesRequestT = Model::SearchEmailAddressesRequest>
  Model::SearchEmailAddressesOutcomeCallable SearchEmailAddressesCallable(const SearchEmailAddressesRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchEmailAddresses, request);
  }
 
  template <typename SearchEmailAddressesRequestT = Model::SearchEmailAddressesRequest>
  void SearchEmailAddressesAsync(const SearchEmailAddressesRequestT& request, const SearchEmailAddressesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchEmailAddresses, request, handler, context);
  }
 
  virtual Model::SearchEvaluationFormsOutcome SearchEvaluationForms(const Model::SearchEvaluationFormsRequest& request) const;
 
  template <typename SearchEvaluationFormsRequestT = Model::SearchEvaluationFormsRequest>
  Model::SearchEvaluationFormsOutcomeCallable SearchEvaluationFormsCallable(const SearchEvaluationFormsRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchEvaluationForms, request);
  }
 
  template <typename SearchEvaluationFormsRequestT = Model::SearchEvaluationFormsRequest>
  void SearchEvaluationFormsAsync(const SearchEvaluationFormsRequestT& request, const SearchEvaluationFormsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchEvaluationForms, request, handler, context);
  }
 
  virtual Model::SearchHoursOfOperationOverridesOutcome SearchHoursOfOperationOverrides(
      const Model::SearchHoursOfOperationOverridesRequest& request) const;
 
  template <typename SearchHoursOfOperationOverridesRequestT = Model::SearchHoursOfOperationOverridesRequest>
  Model::SearchHoursOfOperationOverridesOutcomeCallable SearchHoursOfOperationOverridesCallable(
      const SearchHoursOfOperationOverridesRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchHoursOfOperationOverrides, request);
  }
 
  template <typename SearchHoursOfOperationOverridesRequestT = Model::SearchHoursOfOperationOverridesRequest>
  void SearchHoursOfOperationOverridesAsync(const SearchHoursOfOperationOverridesRequestT& request,
                                            const SearchHoursOfOperationOverridesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchHoursOfOperationOverrides, 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::SearchNotificationsOutcome SearchNotifications(const Model::SearchNotificationsRequest& request) const;
 
  template <typename SearchNotificationsRequestT = Model::SearchNotificationsRequest>
  Model::SearchNotificationsOutcomeCallable SearchNotificationsCallable(const SearchNotificationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchNotifications, request);
  }
 
  template <typename SearchNotificationsRequestT = Model::SearchNotificationsRequest>
  void SearchNotificationsAsync(const SearchNotificationsRequestT& request, const SearchNotificationsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchNotifications, 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::SearchTestCasesOutcome SearchTestCases(const Model::SearchTestCasesRequest& request) const;
 
  template <typename SearchTestCasesRequestT = Model::SearchTestCasesRequest>
  Model::SearchTestCasesOutcomeCallable SearchTestCasesCallable(const SearchTestCasesRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchTestCases, request);
  }
 
  template <typename SearchTestCasesRequestT = Model::SearchTestCasesRequest>
  void SearchTestCasesAsync(const SearchTestCasesRequestT& request, const SearchTestCasesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchTestCases, 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::SearchViewsOutcome SearchViews(const Model::SearchViewsRequest& request) const;
 
  template <typename SearchViewsRequestT = Model::SearchViewsRequest>
  Model::SearchViewsOutcomeCallable SearchViewsCallable(const SearchViewsRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchViews, request);
  }
 
  template <typename SearchViewsRequestT = Model::SearchViewsRequest>
  void SearchViewsAsync(const SearchViewsRequestT& request, const SearchViewsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchViews, 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::SearchWorkspaceAssociationsOutcome SearchWorkspaceAssociations(
      const Model::SearchWorkspaceAssociationsRequest& request) const;
 
  template <typename SearchWorkspaceAssociationsRequestT = Model::SearchWorkspaceAssociationsRequest>
  Model::SearchWorkspaceAssociationsOutcomeCallable SearchWorkspaceAssociationsCallable(
      const SearchWorkspaceAssociationsRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchWorkspaceAssociations, request);
  }
 
  template <typename SearchWorkspaceAssociationsRequestT = Model::SearchWorkspaceAssociationsRequest>
  void SearchWorkspaceAssociationsAsync(const SearchWorkspaceAssociationsRequestT& request,
                                        const SearchWorkspaceAssociationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchWorkspaceAssociations, request, handler, context);
  }
 
  virtual Model::SearchWorkspacesOutcome SearchWorkspaces(const Model::SearchWorkspacesRequest& request) const;
 
  template <typename SearchWorkspacesRequestT = Model::SearchWorkspacesRequest>
  Model::SearchWorkspacesOutcomeCallable SearchWorkspacesCallable(const SearchWorkspacesRequestT& request) const {
    return SubmitCallable(&ConnectClient::SearchWorkspaces, request);
  }
 
  template <typename SearchWorkspacesRequestT = Model::SearchWorkspacesRequest>
  void SearchWorkspacesAsync(const SearchWorkspacesRequestT& request, const SearchWorkspacesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SearchWorkspaces, 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::SendOutboundEmailOutcome SendOutboundEmail(const Model::SendOutboundEmailRequest& request) const;
 
  template <typename SendOutboundEmailRequestT = Model::SendOutboundEmailRequest>
  Model::SendOutboundEmailOutcomeCallable SendOutboundEmailCallable(const SendOutboundEmailRequestT& request) const {
    return SubmitCallable(&ConnectClient::SendOutboundEmail, request);
  }
 
  template <typename SendOutboundEmailRequestT = Model::SendOutboundEmailRequest>
  void SendOutboundEmailAsync(const SendOutboundEmailRequestT& request, const SendOutboundEmailResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::SendOutboundEmail, 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::StartContactMediaProcessingOutcome StartContactMediaProcessing(
      const Model::StartContactMediaProcessingRequest& request = {}) const;
 
  template <typename StartContactMediaProcessingRequestT = Model::StartContactMediaProcessingRequest>
  Model::StartContactMediaProcessingOutcomeCallable StartContactMediaProcessingCallable(
      const StartContactMediaProcessingRequestT& request = {}) const {
    return SubmitCallable(&ConnectClient::StartContactMediaProcessing, request);
  }
 
  template <typename StartContactMediaProcessingRequestT = Model::StartContactMediaProcessingRequest>
  void StartContactMediaProcessingAsync(const StartContactMediaProcessingResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const StartContactMediaProcessingRequestT& request = {}) const {
    return SubmitAsync(&ConnectClient::StartContactMediaProcessing, 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::StartEmailContactOutcome StartEmailContact(const Model::StartEmailContactRequest& request) const;
 
  template <typename StartEmailContactRequestT = Model::StartEmailContactRequest>
  Model::StartEmailContactOutcomeCallable StartEmailContactCallable(const StartEmailContactRequestT& request) const {
    return SubmitCallable(&ConnectClient::StartEmailContact, request);
  }
 
  template <typename StartEmailContactRequestT = Model::StartEmailContactRequest>
  void StartEmailContactAsync(const StartEmailContactRequestT& request, const StartEmailContactResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::StartEmailContact, 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::StartOutboundEmailContactOutcome StartOutboundEmailContact(const Model::StartOutboundEmailContactRequest& request) const;
 
  template <typename StartOutboundEmailContactRequestT = Model::StartOutboundEmailContactRequest>
  Model::StartOutboundEmailContactOutcomeCallable StartOutboundEmailContactCallable(
      const StartOutboundEmailContactRequestT& request) const {
    return SubmitCallable(&ConnectClient::StartOutboundEmailContact, request);
  }
 
  template <typename StartOutboundEmailContactRequestT = Model::StartOutboundEmailContactRequest>
  void StartOutboundEmailContactAsync(const StartOutboundEmailContactRequestT& request,
                                      const StartOutboundEmailContactResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::StartOutboundEmailContact, 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::StartTestCaseExecutionOutcome StartTestCaseExecution(const Model::StartTestCaseExecutionRequest& request) const;
 
  template <typename StartTestCaseExecutionRequestT = Model::StartTestCaseExecutionRequest>
  Model::StartTestCaseExecutionOutcomeCallable StartTestCaseExecutionCallable(const StartTestCaseExecutionRequestT& request) const {
    return SubmitCallable(&ConnectClient::StartTestCaseExecution, request);
  }
 
  template <typename StartTestCaseExecutionRequestT = Model::StartTestCaseExecutionRequest>
  void StartTestCaseExecutionAsync(const StartTestCaseExecutionRequestT& request,
                                   const StartTestCaseExecutionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::StartTestCaseExecution, 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::StopContactMediaProcessingOutcome StopContactMediaProcessing(
      const Model::StopContactMediaProcessingRequest& request = {}) const;
 
  template <typename StopContactMediaProcessingRequestT = Model::StopContactMediaProcessingRequest>
  Model::StopContactMediaProcessingOutcomeCallable StopContactMediaProcessingCallable(
      const StopContactMediaProcessingRequestT& request = {}) const {
    return SubmitCallable(&ConnectClient::StopContactMediaProcessing, request);
  }
 
  template <typename StopContactMediaProcessingRequestT = Model::StopContactMediaProcessingRequest>
  void StopContactMediaProcessingAsync(const StopContactMediaProcessingResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const StopContactMediaProcessingRequestT& request = {}) const {
    return SubmitAsync(&ConnectClient::StopContactMediaProcessing, 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::StopTestCaseExecutionOutcome StopTestCaseExecution(const Model::StopTestCaseExecutionRequest& request) const;
 
  template <typename StopTestCaseExecutionRequestT = Model::StopTestCaseExecutionRequest>
  Model::StopTestCaseExecutionOutcomeCallable StopTestCaseExecutionCallable(const StopTestCaseExecutionRequestT& request) const {
    return SubmitCallable(&ConnectClient::StopTestCaseExecution, request);
  }
 
  template <typename StopTestCaseExecutionRequestT = Model::StopTestCaseExecutionRequest>
  void StopTestCaseExecutionAsync(const StopTestCaseExecutionRequestT& request, const StopTestCaseExecutionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::StopTestCaseExecution, 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::UpdateContactFlowModuleAliasOutcome UpdateContactFlowModuleAlias(
      const Model::UpdateContactFlowModuleAliasRequest& request) const;
 
  template <typename UpdateContactFlowModuleAliasRequestT = Model::UpdateContactFlowModuleAliasRequest>
  Model::UpdateContactFlowModuleAliasOutcomeCallable UpdateContactFlowModuleAliasCallable(
      const UpdateContactFlowModuleAliasRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateContactFlowModuleAlias, request);
  }
 
  template <typename UpdateContactFlowModuleAliasRequestT = Model::UpdateContactFlowModuleAliasRequest>
  void UpdateContactFlowModuleAliasAsync(const UpdateContactFlowModuleAliasRequestT& request,
                                         const UpdateContactFlowModuleAliasResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateContactFlowModuleAlias, 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::UpdateDataTableAttributeOutcome UpdateDataTableAttribute(const Model::UpdateDataTableAttributeRequest& request) const;
 
  template <typename UpdateDataTableAttributeRequestT = Model::UpdateDataTableAttributeRequest>
  Model::UpdateDataTableAttributeOutcomeCallable UpdateDataTableAttributeCallable(const UpdateDataTableAttributeRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateDataTableAttribute, request);
  }
 
  template <typename UpdateDataTableAttributeRequestT = Model::UpdateDataTableAttributeRequest>
  void UpdateDataTableAttributeAsync(const UpdateDataTableAttributeRequestT& request,
                                     const UpdateDataTableAttributeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateDataTableAttribute, request, handler, context);
  }
 
  virtual Model::UpdateDataTableMetadataOutcome UpdateDataTableMetadata(const Model::UpdateDataTableMetadataRequest& request) const;
 
  template <typename UpdateDataTableMetadataRequestT = Model::UpdateDataTableMetadataRequest>
  Model::UpdateDataTableMetadataOutcomeCallable UpdateDataTableMetadataCallable(const UpdateDataTableMetadataRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateDataTableMetadata, request);
  }
 
  template <typename UpdateDataTableMetadataRequestT = Model::UpdateDataTableMetadataRequest>
  void UpdateDataTableMetadataAsync(const UpdateDataTableMetadataRequestT& request,
                                    const UpdateDataTableMetadataResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateDataTableMetadata, request, handler, context);
  }
 
  virtual Model::UpdateDataTablePrimaryValuesOutcome UpdateDataTablePrimaryValues(
      const Model::UpdateDataTablePrimaryValuesRequest& request) const;
 
  template <typename UpdateDataTablePrimaryValuesRequestT = Model::UpdateDataTablePrimaryValuesRequest>
  Model::UpdateDataTablePrimaryValuesOutcomeCallable UpdateDataTablePrimaryValuesCallable(
      const UpdateDataTablePrimaryValuesRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateDataTablePrimaryValues, request);
  }
 
  template <typename UpdateDataTablePrimaryValuesRequestT = Model::UpdateDataTablePrimaryValuesRequest>
  void UpdateDataTablePrimaryValuesAsync(const UpdateDataTablePrimaryValuesRequestT& request,
                                         const UpdateDataTablePrimaryValuesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateDataTablePrimaryValues, request, handler, context);
  }
 
  virtual Model::UpdateEmailAddressMetadataOutcome UpdateEmailAddressMetadata(
      const Model::UpdateEmailAddressMetadataRequest& request) const;
 
  template <typename UpdateEmailAddressMetadataRequestT = Model::UpdateEmailAddressMetadataRequest>
  Model::UpdateEmailAddressMetadataOutcomeCallable UpdateEmailAddressMetadataCallable(
      const UpdateEmailAddressMetadataRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateEmailAddressMetadata, request);
  }
 
  template <typename UpdateEmailAddressMetadataRequestT = Model::UpdateEmailAddressMetadataRequest>
  void UpdateEmailAddressMetadataAsync(const UpdateEmailAddressMetadataRequestT& request,
                                       const UpdateEmailAddressMetadataResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateEmailAddressMetadata, 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::UpdateHoursOfOperationOverrideOutcome UpdateHoursOfOperationOverride(
      const Model::UpdateHoursOfOperationOverrideRequest& request) const;
 
  template <typename UpdateHoursOfOperationOverrideRequestT = Model::UpdateHoursOfOperationOverrideRequest>
  Model::UpdateHoursOfOperationOverrideOutcomeCallable UpdateHoursOfOperationOverrideCallable(
      const UpdateHoursOfOperationOverrideRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateHoursOfOperationOverride, request);
  }
 
  template <typename UpdateHoursOfOperationOverrideRequestT = Model::UpdateHoursOfOperationOverrideRequest>
  void UpdateHoursOfOperationOverrideAsync(const UpdateHoursOfOperationOverrideRequestT& request,
                                           const UpdateHoursOfOperationOverrideResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateHoursOfOperationOverride, 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::UpdateNotificationContentOutcome UpdateNotificationContent(const Model::UpdateNotificationContentRequest& request) const;
 
  template <typename UpdateNotificationContentRequestT = Model::UpdateNotificationContentRequest>
  Model::UpdateNotificationContentOutcomeCallable UpdateNotificationContentCallable(
      const UpdateNotificationContentRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateNotificationContent, request);
  }
 
  template <typename UpdateNotificationContentRequestT = Model::UpdateNotificationContentRequest>
  void UpdateNotificationContentAsync(const UpdateNotificationContentRequestT& request,
                                      const UpdateNotificationContentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateNotificationContent, request, handler, context);
  }
 
  virtual Model::UpdateParticipantAuthenticationOutcome UpdateParticipantAuthentication(
      const Model::UpdateParticipantAuthenticationRequest& request) const;
 
  template <typename UpdateParticipantAuthenticationRequestT = Model::UpdateParticipantAuthenticationRequest>
  Model::UpdateParticipantAuthenticationOutcomeCallable UpdateParticipantAuthenticationCallable(
      const UpdateParticipantAuthenticationRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateParticipantAuthentication, request);
  }
 
  template <typename UpdateParticipantAuthenticationRequestT = Model::UpdateParticipantAuthenticationRequest>
  void UpdateParticipantAuthenticationAsync(const UpdateParticipantAuthenticationRequestT& request,
                                            const UpdateParticipantAuthenticationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateParticipantAuthentication, 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::UpdateQueueOutboundEmailConfigOutcome UpdateQueueOutboundEmailConfig(
      const Model::UpdateQueueOutboundEmailConfigRequest& request) const;
 
  template <typename UpdateQueueOutboundEmailConfigRequestT = Model::UpdateQueueOutboundEmailConfigRequest>
  Model::UpdateQueueOutboundEmailConfigOutcomeCallable UpdateQueueOutboundEmailConfigCallable(
      const UpdateQueueOutboundEmailConfigRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateQueueOutboundEmailConfig, request);
  }
 
  template <typename UpdateQueueOutboundEmailConfigRequestT = Model::UpdateQueueOutboundEmailConfigRequest>
  void UpdateQueueOutboundEmailConfigAsync(const UpdateQueueOutboundEmailConfigRequestT& request,
                                           const UpdateQueueOutboundEmailConfigResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateQueueOutboundEmailConfig, 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::UpdateTestCaseOutcome UpdateTestCase(const Model::UpdateTestCaseRequest& request) const;
 
  template <typename UpdateTestCaseRequestT = Model::UpdateTestCaseRequest>
  Model::UpdateTestCaseOutcomeCallable UpdateTestCaseCallable(const UpdateTestCaseRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateTestCase, request);
  }
 
  template <typename UpdateTestCaseRequestT = Model::UpdateTestCaseRequest>
  void UpdateTestCaseAsync(const UpdateTestCaseRequestT& request, const UpdateTestCaseResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateTestCase, 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::UpdateUserConfigOutcome UpdateUserConfig(const Model::UpdateUserConfigRequest& request) const;
 
  template <typename UpdateUserConfigRequestT = Model::UpdateUserConfigRequest>
  Model::UpdateUserConfigOutcomeCallable UpdateUserConfigCallable(const UpdateUserConfigRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateUserConfig, request);
  }
 
  template <typename UpdateUserConfigRequestT = Model::UpdateUserConfigRequest>
  void UpdateUserConfigAsync(const UpdateUserConfigRequestT& request, const UpdateUserConfigResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateUserConfig, 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::UpdateUserNotificationStatusOutcome UpdateUserNotificationStatus(
      const Model::UpdateUserNotificationStatusRequest& request) const;
 
  template <typename UpdateUserNotificationStatusRequestT = Model::UpdateUserNotificationStatusRequest>
  Model::UpdateUserNotificationStatusOutcomeCallable UpdateUserNotificationStatusCallable(
      const UpdateUserNotificationStatusRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateUserNotificationStatus, request);
  }
 
  template <typename UpdateUserNotificationStatusRequestT = Model::UpdateUserNotificationStatusRequest>
  void UpdateUserNotificationStatusAsync(const UpdateUserNotificationStatusRequestT& request,
                                         const UpdateUserNotificationStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateUserNotificationStatus, 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);
  }
 
  virtual Model::UpdateWorkspaceMetadataOutcome UpdateWorkspaceMetadata(const Model::UpdateWorkspaceMetadataRequest& request) const;
 
  template <typename UpdateWorkspaceMetadataRequestT = Model::UpdateWorkspaceMetadataRequest>
  Model::UpdateWorkspaceMetadataOutcomeCallable UpdateWorkspaceMetadataCallable(const UpdateWorkspaceMetadataRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateWorkspaceMetadata, request);
  }
 
  template <typename UpdateWorkspaceMetadataRequestT = Model::UpdateWorkspaceMetadataRequest>
  void UpdateWorkspaceMetadataAsync(const UpdateWorkspaceMetadataRequestT& request,
                                    const UpdateWorkspaceMetadataResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateWorkspaceMetadata, request, handler, context);
  }
 
  virtual Model::UpdateWorkspacePageOutcome UpdateWorkspacePage(const Model::UpdateWorkspacePageRequest& request) const;
 
  template <typename UpdateWorkspacePageRequestT = Model::UpdateWorkspacePageRequest>
  Model::UpdateWorkspacePageOutcomeCallable UpdateWorkspacePageCallable(const UpdateWorkspacePageRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateWorkspacePage, request);
  }
 
  template <typename UpdateWorkspacePageRequestT = Model::UpdateWorkspacePageRequest>
  void UpdateWorkspacePageAsync(const UpdateWorkspacePageRequestT& request, const UpdateWorkspacePageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateWorkspacePage, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceThemeOutcome UpdateWorkspaceTheme(const Model::UpdateWorkspaceThemeRequest& request) const;
 
  template <typename UpdateWorkspaceThemeRequestT = Model::UpdateWorkspaceThemeRequest>
  Model::UpdateWorkspaceThemeOutcomeCallable UpdateWorkspaceThemeCallable(const UpdateWorkspaceThemeRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateWorkspaceTheme, request);
  }
 
  template <typename UpdateWorkspaceThemeRequestT = Model::UpdateWorkspaceThemeRequest>
  void UpdateWorkspaceThemeAsync(const UpdateWorkspaceThemeRequestT& request, const UpdateWorkspaceThemeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateWorkspaceTheme, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceVisibilityOutcome UpdateWorkspaceVisibility(const Model::UpdateWorkspaceVisibilityRequest& request) const;
 
  template <typename UpdateWorkspaceVisibilityRequestT = Model::UpdateWorkspaceVisibilityRequest>
  Model::UpdateWorkspaceVisibilityOutcomeCallable UpdateWorkspaceVisibilityCallable(
      const UpdateWorkspaceVisibilityRequestT& request) const {
    return SubmitCallable(&ConnectClient::UpdateWorkspaceVisibility, request);
  }
 
  template <typename UpdateWorkspaceVisibilityRequestT = Model::UpdateWorkspaceVisibilityRequest>
  void UpdateWorkspaceVisibilityAsync(const UpdateWorkspaceVisibilityRequestT& request,
                                      const UpdateWorkspaceVisibilityResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectClient::UpdateWorkspaceVisibility, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ConnectEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectClient>;
  void init(const ConnectClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ConnectError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ConnectClientConfiguration m_clientConfiguration;
  std::shared_ptr<ConnectEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Connect
}  // namespace Aws