ConnectCampaignsV2Client.h

 
#pragma once
#include <aws/connectcampaignsv2/ConnectCampaignsV2PaginationBase.h>
#include <aws/connectcampaignsv2/ConnectCampaignsV2ServiceClientModel.h>
#include <aws/connectcampaignsv2/ConnectCampaignsV2Waiter.h>
#include <aws/connectcampaignsv2/ConnectCampaignsV2_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 ConnectCampaignsV2 {
class AWS_CONNECTCAMPAIGNSV2_API ConnectCampaignsV2Client : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<ConnectCampaignsV2Client>,
                                                            public ConnectCampaignsV2PaginationBase<ConnectCampaignsV2Client>,
                                                            public ConnectCampaignsV2Waiter<ConnectCampaignsV2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ConnectCampaignsV2ClientConfiguration ClientConfigurationType;
  typedef ConnectCampaignsV2EndpointProvider EndpointProviderType;
 
  ConnectCampaignsV2Client(const Aws::ConnectCampaignsV2::ConnectCampaignsV2ClientConfiguration& clientConfiguration =
                               Aws::ConnectCampaignsV2::ConnectCampaignsV2ClientConfiguration(),
                           std::shared_ptr<ConnectCampaignsV2EndpointProviderBase> endpointProvider = nullptr);
 
  ConnectCampaignsV2Client(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<ConnectCampaignsV2EndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ConnectCampaignsV2::ConnectCampaignsV2ClientConfiguration& clientConfiguration =
                               Aws::ConnectCampaignsV2::ConnectCampaignsV2ClientConfiguration());
 
  ConnectCampaignsV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<ConnectCampaignsV2EndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ConnectCampaignsV2::ConnectCampaignsV2ClientConfiguration& clientConfiguration =
                               Aws::ConnectCampaignsV2::ConnectCampaignsV2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ConnectCampaignsV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectCampaignsV2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectCampaignsV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ConnectCampaignsV2Client();
 
  virtual Model::CreateCampaignOutcome CreateCampaign(const Model::CreateCampaignRequest& request) const;
 
  template <typename CreateCampaignRequestT = Model::CreateCampaignRequest>
  Model::CreateCampaignOutcomeCallable CreateCampaignCallable(const CreateCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::CreateCampaign, request);
  }
 
  template <typename CreateCampaignRequestT = Model::CreateCampaignRequest>
  void CreateCampaignAsync(const CreateCampaignRequestT& request, const CreateCampaignResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::CreateCampaign, request, handler, context);
  }
 
  virtual Model::DeleteCampaignOutcome DeleteCampaign(const Model::DeleteCampaignRequest& request) const;
 
  template <typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
  Model::DeleteCampaignOutcomeCallable DeleteCampaignCallable(const DeleteCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteCampaign, request);
  }
 
  template <typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
  void DeleteCampaignAsync(const DeleteCampaignRequestT& request, const DeleteCampaignResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteCampaign, request, handler, context);
  }
 
  virtual Model::DeleteCampaignChannelSubtypeConfigOutcome DeleteCampaignChannelSubtypeConfig(
      const Model::DeleteCampaignChannelSubtypeConfigRequest& request) const;
 
  template <typename DeleteCampaignChannelSubtypeConfigRequestT = Model::DeleteCampaignChannelSubtypeConfigRequest>
  Model::DeleteCampaignChannelSubtypeConfigOutcomeCallable DeleteCampaignChannelSubtypeConfigCallable(
      const DeleteCampaignChannelSubtypeConfigRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteCampaignChannelSubtypeConfig, request);
  }
 
  template <typename DeleteCampaignChannelSubtypeConfigRequestT = Model::DeleteCampaignChannelSubtypeConfigRequest>
  void DeleteCampaignChannelSubtypeConfigAsync(const DeleteCampaignChannelSubtypeConfigRequestT& request,
                                               const DeleteCampaignChannelSubtypeConfigResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteCampaignChannelSubtypeConfig, request, handler, context);
  }
 
  virtual Model::DeleteCampaignCommunicationLimitsOutcome DeleteCampaignCommunicationLimits(
      const Model::DeleteCampaignCommunicationLimitsRequest& request) const;
 
  template <typename DeleteCampaignCommunicationLimitsRequestT = Model::DeleteCampaignCommunicationLimitsRequest>
  Model::DeleteCampaignCommunicationLimitsOutcomeCallable DeleteCampaignCommunicationLimitsCallable(
      const DeleteCampaignCommunicationLimitsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteCampaignCommunicationLimits, request);
  }
 
  template <typename DeleteCampaignCommunicationLimitsRequestT = Model::DeleteCampaignCommunicationLimitsRequest>
  void DeleteCampaignCommunicationLimitsAsync(const DeleteCampaignCommunicationLimitsRequestT& request,
                                              const DeleteCampaignCommunicationLimitsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteCampaignCommunicationLimits, request, handler, context);
  }
 
  virtual Model::DeleteCampaignCommunicationTimeOutcome DeleteCampaignCommunicationTime(
      const Model::DeleteCampaignCommunicationTimeRequest& request) const;
 
  template <typename DeleteCampaignCommunicationTimeRequestT = Model::DeleteCampaignCommunicationTimeRequest>
  Model::DeleteCampaignCommunicationTimeOutcomeCallable DeleteCampaignCommunicationTimeCallable(
      const DeleteCampaignCommunicationTimeRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteCampaignCommunicationTime, request);
  }
 
  template <typename DeleteCampaignCommunicationTimeRequestT = Model::DeleteCampaignCommunicationTimeRequest>
  void DeleteCampaignCommunicationTimeAsync(const DeleteCampaignCommunicationTimeRequestT& request,
                                            const DeleteCampaignCommunicationTimeResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteCampaignCommunicationTime, request, handler, context);
  }
 
  virtual Model::DeleteCampaignEntryLimitsOutcome DeleteCampaignEntryLimits(const Model::DeleteCampaignEntryLimitsRequest& request) const;
 
  template <typename DeleteCampaignEntryLimitsRequestT = Model::DeleteCampaignEntryLimitsRequest>
  Model::DeleteCampaignEntryLimitsOutcomeCallable DeleteCampaignEntryLimitsCallable(
      const DeleteCampaignEntryLimitsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteCampaignEntryLimits, request);
  }
 
  template <typename DeleteCampaignEntryLimitsRequestT = Model::DeleteCampaignEntryLimitsRequest>
  void DeleteCampaignEntryLimitsAsync(const DeleteCampaignEntryLimitsRequestT& request,
                                      const DeleteCampaignEntryLimitsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteCampaignEntryLimits, request, handler, context);
  }
 
  virtual Model::DeleteConnectInstanceConfigOutcome DeleteConnectInstanceConfig(
      const Model::DeleteConnectInstanceConfigRequest& request) const;
 
  template <typename DeleteConnectInstanceConfigRequestT = Model::DeleteConnectInstanceConfigRequest>
  Model::DeleteConnectInstanceConfigOutcomeCallable DeleteConnectInstanceConfigCallable(
      const DeleteConnectInstanceConfigRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteConnectInstanceConfig, request);
  }
 
  template <typename DeleteConnectInstanceConfigRequestT = Model::DeleteConnectInstanceConfigRequest>
  void DeleteConnectInstanceConfigAsync(const DeleteConnectInstanceConfigRequestT& request,
                                        const DeleteConnectInstanceConfigResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteConnectInstanceConfig, request, handler, context);
  }
 
  virtual Model::DeleteConnectInstanceIntegrationOutcome DeleteConnectInstanceIntegration(
      const Model::DeleteConnectInstanceIntegrationRequest& request) const;
 
  template <typename DeleteConnectInstanceIntegrationRequestT = Model::DeleteConnectInstanceIntegrationRequest>
  Model::DeleteConnectInstanceIntegrationOutcomeCallable DeleteConnectInstanceIntegrationCallable(
      const DeleteConnectInstanceIntegrationRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteConnectInstanceIntegration, request);
  }
 
  template <typename DeleteConnectInstanceIntegrationRequestT = Model::DeleteConnectInstanceIntegrationRequest>
  void DeleteConnectInstanceIntegrationAsync(const DeleteConnectInstanceIntegrationRequestT& request,
                                             const DeleteConnectInstanceIntegrationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteConnectInstanceIntegration, request, handler, context);
  }
 
  virtual Model::DeleteInstanceOnboardingJobOutcome DeleteInstanceOnboardingJob(
      const Model::DeleteInstanceOnboardingJobRequest& request) const;
 
  template <typename DeleteInstanceOnboardingJobRequestT = Model::DeleteInstanceOnboardingJobRequest>
  Model::DeleteInstanceOnboardingJobOutcomeCallable DeleteInstanceOnboardingJobCallable(
      const DeleteInstanceOnboardingJobRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DeleteInstanceOnboardingJob, request);
  }
 
  template <typename DeleteInstanceOnboardingJobRequestT = Model::DeleteInstanceOnboardingJobRequest>
  void DeleteInstanceOnboardingJobAsync(const DeleteInstanceOnboardingJobRequestT& request,
                                        const DeleteInstanceOnboardingJobResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DeleteInstanceOnboardingJob, request, handler, context);
  }
 
  virtual Model::DescribeCampaignOutcome DescribeCampaign(const Model::DescribeCampaignRequest& request) const;
 
  template <typename DescribeCampaignRequestT = Model::DescribeCampaignRequest>
  Model::DescribeCampaignOutcomeCallable DescribeCampaignCallable(const DescribeCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::DescribeCampaign, request);
  }
 
  template <typename DescribeCampaignRequestT = Model::DescribeCampaignRequest>
  void DescribeCampaignAsync(const DescribeCampaignRequestT& request, const DescribeCampaignResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::DescribeCampaign, request, handler, context);
  }
 
  virtual Model::GetCampaignStateOutcome GetCampaignState(const Model::GetCampaignStateRequest& request) const;
 
  template <typename GetCampaignStateRequestT = Model::GetCampaignStateRequest>
  Model::GetCampaignStateOutcomeCallable GetCampaignStateCallable(const GetCampaignStateRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::GetCampaignState, request);
  }
 
  template <typename GetCampaignStateRequestT = Model::GetCampaignStateRequest>
  void GetCampaignStateAsync(const GetCampaignStateRequestT& request, const GetCampaignStateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::GetCampaignState, request, handler, context);
  }
 
  virtual Model::GetCampaignStateBatchOutcome GetCampaignStateBatch(const Model::GetCampaignStateBatchRequest& request) const;
 
  template <typename GetCampaignStateBatchRequestT = Model::GetCampaignStateBatchRequest>
  Model::GetCampaignStateBatchOutcomeCallable GetCampaignStateBatchCallable(const GetCampaignStateBatchRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::GetCampaignStateBatch, request);
  }
 
  template <typename GetCampaignStateBatchRequestT = Model::GetCampaignStateBatchRequest>
  void GetCampaignStateBatchAsync(const GetCampaignStateBatchRequestT& request, const GetCampaignStateBatchResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::GetCampaignStateBatch, request, handler, context);
  }
 
  virtual Model::GetConnectInstanceConfigOutcome GetConnectInstanceConfig(const Model::GetConnectInstanceConfigRequest& request) const;
 
  template <typename GetConnectInstanceConfigRequestT = Model::GetConnectInstanceConfigRequest>
  Model::GetConnectInstanceConfigOutcomeCallable GetConnectInstanceConfigCallable(const GetConnectInstanceConfigRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::GetConnectInstanceConfig, request);
  }
 
  template <typename GetConnectInstanceConfigRequestT = Model::GetConnectInstanceConfigRequest>
  void GetConnectInstanceConfigAsync(const GetConnectInstanceConfigRequestT& request,
                                     const GetConnectInstanceConfigResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::GetConnectInstanceConfig, request, handler, context);
  }
 
  virtual Model::GetInstanceCommunicationLimitsOutcome GetInstanceCommunicationLimits(
      const Model::GetInstanceCommunicationLimitsRequest& request) const;
 
  template <typename GetInstanceCommunicationLimitsRequestT = Model::GetInstanceCommunicationLimitsRequest>
  Model::GetInstanceCommunicationLimitsOutcomeCallable GetInstanceCommunicationLimitsCallable(
      const GetInstanceCommunicationLimitsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::GetInstanceCommunicationLimits, request);
  }
 
  template <typename GetInstanceCommunicationLimitsRequestT = Model::GetInstanceCommunicationLimitsRequest>
  void GetInstanceCommunicationLimitsAsync(const GetInstanceCommunicationLimitsRequestT& request,
                                           const GetInstanceCommunicationLimitsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::GetInstanceCommunicationLimits, request, handler, context);
  }
 
  virtual Model::GetInstanceOnboardingJobStatusOutcome GetInstanceOnboardingJobStatus(
      const Model::GetInstanceOnboardingJobStatusRequest& request) const;
 
  template <typename GetInstanceOnboardingJobStatusRequestT = Model::GetInstanceOnboardingJobStatusRequest>
  Model::GetInstanceOnboardingJobStatusOutcomeCallable GetInstanceOnboardingJobStatusCallable(
      const GetInstanceOnboardingJobStatusRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::GetInstanceOnboardingJobStatus, request);
  }
 
  template <typename GetInstanceOnboardingJobStatusRequestT = Model::GetInstanceOnboardingJobStatusRequest>
  void GetInstanceOnboardingJobStatusAsync(const GetInstanceOnboardingJobStatusRequestT& request,
                                           const GetInstanceOnboardingJobStatusResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::GetInstanceOnboardingJobStatus, request, handler, context);
  }
 
  virtual Model::ListCampaignsOutcome ListCampaigns(const Model::ListCampaignsRequest& request = {}) const;
 
  template <typename ListCampaignsRequestT = Model::ListCampaignsRequest>
  Model::ListCampaignsOutcomeCallable ListCampaignsCallable(const ListCampaignsRequestT& request = {}) const {
    return SubmitCallable(&ConnectCampaignsV2Client::ListCampaigns, request);
  }
 
  template <typename ListCampaignsRequestT = Model::ListCampaignsRequest>
  void ListCampaignsAsync(const ListCampaignsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListCampaignsRequestT& request = {}) const {
    return SubmitAsync(&ConnectCampaignsV2Client::ListCampaigns, request, handler, context);
  }
 
  virtual Model::ListConnectInstanceIntegrationsOutcome ListConnectInstanceIntegrations(
      const Model::ListConnectInstanceIntegrationsRequest& request) const;
 
  template <typename ListConnectInstanceIntegrationsRequestT = Model::ListConnectInstanceIntegrationsRequest>
  Model::ListConnectInstanceIntegrationsOutcomeCallable ListConnectInstanceIntegrationsCallable(
      const ListConnectInstanceIntegrationsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::ListConnectInstanceIntegrations, request);
  }
 
  template <typename ListConnectInstanceIntegrationsRequestT = Model::ListConnectInstanceIntegrationsRequest>
  void ListConnectInstanceIntegrationsAsync(const ListConnectInstanceIntegrationsRequestT& request,
                                            const ListConnectInstanceIntegrationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::ListConnectInstanceIntegrations, 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(&ConnectCampaignsV2Client::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(&ConnectCampaignsV2Client::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PauseCampaignOutcome PauseCampaign(const Model::PauseCampaignRequest& request) const;
 
  template <typename PauseCampaignRequestT = Model::PauseCampaignRequest>
  Model::PauseCampaignOutcomeCallable PauseCampaignCallable(const PauseCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::PauseCampaign, request);
  }
 
  template <typename PauseCampaignRequestT = Model::PauseCampaignRequest>
  void PauseCampaignAsync(const PauseCampaignRequestT& request, const PauseCampaignResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::PauseCampaign, request, handler, context);
  }
 
  virtual Model::PutConnectInstanceIntegrationOutcome PutConnectInstanceIntegration(
      const Model::PutConnectInstanceIntegrationRequest& request) const;
 
  template <typename PutConnectInstanceIntegrationRequestT = Model::PutConnectInstanceIntegrationRequest>
  Model::PutConnectInstanceIntegrationOutcomeCallable PutConnectInstanceIntegrationCallable(
      const PutConnectInstanceIntegrationRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::PutConnectInstanceIntegration, request);
  }
 
  template <typename PutConnectInstanceIntegrationRequestT = Model::PutConnectInstanceIntegrationRequest>
  void PutConnectInstanceIntegrationAsync(const PutConnectInstanceIntegrationRequestT& request,
                                          const PutConnectInstanceIntegrationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::PutConnectInstanceIntegration, request, handler, context);
  }
 
  virtual Model::PutInstanceCommunicationLimitsOutcome PutInstanceCommunicationLimits(
      const Model::PutInstanceCommunicationLimitsRequest& request) const;
 
  template <typename PutInstanceCommunicationLimitsRequestT = Model::PutInstanceCommunicationLimitsRequest>
  Model::PutInstanceCommunicationLimitsOutcomeCallable PutInstanceCommunicationLimitsCallable(
      const PutInstanceCommunicationLimitsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::PutInstanceCommunicationLimits, request);
  }
 
  template <typename PutInstanceCommunicationLimitsRequestT = Model::PutInstanceCommunicationLimitsRequest>
  void PutInstanceCommunicationLimitsAsync(const PutInstanceCommunicationLimitsRequestT& request,
                                           const PutInstanceCommunicationLimitsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::PutInstanceCommunicationLimits, request, handler, context);
  }
 
  virtual Model::PutOutboundRequestBatchOutcome PutOutboundRequestBatch(const Model::PutOutboundRequestBatchRequest& request) const;
 
  template <typename PutOutboundRequestBatchRequestT = Model::PutOutboundRequestBatchRequest>
  Model::PutOutboundRequestBatchOutcomeCallable PutOutboundRequestBatchCallable(const PutOutboundRequestBatchRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::PutOutboundRequestBatch, request);
  }
 
  template <typename PutOutboundRequestBatchRequestT = Model::PutOutboundRequestBatchRequest>
  void PutOutboundRequestBatchAsync(const PutOutboundRequestBatchRequestT& request,
                                    const PutOutboundRequestBatchResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::PutOutboundRequestBatch, request, handler, context);
  }
 
  virtual Model::PutProfileOutboundRequestBatchOutcome PutProfileOutboundRequestBatch(
      const Model::PutProfileOutboundRequestBatchRequest& request) const;
 
  template <typename PutProfileOutboundRequestBatchRequestT = Model::PutProfileOutboundRequestBatchRequest>
  Model::PutProfileOutboundRequestBatchOutcomeCallable PutProfileOutboundRequestBatchCallable(
      const PutProfileOutboundRequestBatchRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::PutProfileOutboundRequestBatch, request);
  }
 
  template <typename PutProfileOutboundRequestBatchRequestT = Model::PutProfileOutboundRequestBatchRequest>
  void PutProfileOutboundRequestBatchAsync(const PutProfileOutboundRequestBatchRequestT& request,
                                           const PutProfileOutboundRequestBatchResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::PutProfileOutboundRequestBatch, request, handler, context);
  }
 
  virtual Model::ResumeCampaignOutcome ResumeCampaign(const Model::ResumeCampaignRequest& request) const;
 
  template <typename ResumeCampaignRequestT = Model::ResumeCampaignRequest>
  Model::ResumeCampaignOutcomeCallable ResumeCampaignCallable(const ResumeCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::ResumeCampaign, request);
  }
 
  template <typename ResumeCampaignRequestT = Model::ResumeCampaignRequest>
  void ResumeCampaignAsync(const ResumeCampaignRequestT& request, const ResumeCampaignResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::ResumeCampaign, request, handler, context);
  }
 
  virtual Model::StartCampaignOutcome StartCampaign(const Model::StartCampaignRequest& request) const;
 
  template <typename StartCampaignRequestT = Model::StartCampaignRequest>
  Model::StartCampaignOutcomeCallable StartCampaignCallable(const StartCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::StartCampaign, request);
  }
 
  template <typename StartCampaignRequestT = Model::StartCampaignRequest>
  void StartCampaignAsync(const StartCampaignRequestT& request, const StartCampaignResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::StartCampaign, request, handler, context);
  }
 
  virtual Model::StartInstanceOnboardingJobOutcome StartInstanceOnboardingJob(
      const Model::StartInstanceOnboardingJobRequest& request) const;
 
  template <typename StartInstanceOnboardingJobRequestT = Model::StartInstanceOnboardingJobRequest>
  Model::StartInstanceOnboardingJobOutcomeCallable StartInstanceOnboardingJobCallable(
      const StartInstanceOnboardingJobRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::StartInstanceOnboardingJob, request);
  }
 
  template <typename StartInstanceOnboardingJobRequestT = Model::StartInstanceOnboardingJobRequest>
  void StartInstanceOnboardingJobAsync(const StartInstanceOnboardingJobRequestT& request,
                                       const StartInstanceOnboardingJobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::StartInstanceOnboardingJob, request, handler, context);
  }
 
  virtual Model::StopCampaignOutcome StopCampaign(const Model::StopCampaignRequest& request) const;
 
  template <typename StopCampaignRequestT = Model::StopCampaignRequest>
  Model::StopCampaignOutcomeCallable StopCampaignCallable(const StopCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::StopCampaign, request);
  }
 
  template <typename StopCampaignRequestT = Model::StopCampaignRequest>
  void StopCampaignAsync(const StopCampaignRequestT& request, const StopCampaignResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::StopCampaign, 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(&ConnectCampaignsV2Client::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(&ConnectCampaignsV2Client::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::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(&ConnectCampaignsV2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCampaignChannelSubtypeConfigOutcome UpdateCampaignChannelSubtypeConfig(
      const Model::UpdateCampaignChannelSubtypeConfigRequest& request) const;
 
  template <typename UpdateCampaignChannelSubtypeConfigRequestT = Model::UpdateCampaignChannelSubtypeConfigRequest>
  Model::UpdateCampaignChannelSubtypeConfigOutcomeCallable UpdateCampaignChannelSubtypeConfigCallable(
      const UpdateCampaignChannelSubtypeConfigRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignChannelSubtypeConfig, request);
  }
 
  template <typename UpdateCampaignChannelSubtypeConfigRequestT = Model::UpdateCampaignChannelSubtypeConfigRequest>
  void UpdateCampaignChannelSubtypeConfigAsync(const UpdateCampaignChannelSubtypeConfigRequestT& request,
                                               const UpdateCampaignChannelSubtypeConfigResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignChannelSubtypeConfig, request, handler, context);
  }
 
  virtual Model::UpdateCampaignCommunicationLimitsOutcome UpdateCampaignCommunicationLimits(
      const Model::UpdateCampaignCommunicationLimitsRequest& request) const;
 
  template <typename UpdateCampaignCommunicationLimitsRequestT = Model::UpdateCampaignCommunicationLimitsRequest>
  Model::UpdateCampaignCommunicationLimitsOutcomeCallable UpdateCampaignCommunicationLimitsCallable(
      const UpdateCampaignCommunicationLimitsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignCommunicationLimits, request);
  }
 
  template <typename UpdateCampaignCommunicationLimitsRequestT = Model::UpdateCampaignCommunicationLimitsRequest>
  void UpdateCampaignCommunicationLimitsAsync(const UpdateCampaignCommunicationLimitsRequestT& request,
                                              const UpdateCampaignCommunicationLimitsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignCommunicationLimits, request, handler, context);
  }
 
  virtual Model::UpdateCampaignCommunicationTimeOutcome UpdateCampaignCommunicationTime(
      const Model::UpdateCampaignCommunicationTimeRequest& request) const;
 
  template <typename UpdateCampaignCommunicationTimeRequestT = Model::UpdateCampaignCommunicationTimeRequest>
  Model::UpdateCampaignCommunicationTimeOutcomeCallable UpdateCampaignCommunicationTimeCallable(
      const UpdateCampaignCommunicationTimeRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignCommunicationTime, request);
  }
 
  template <typename UpdateCampaignCommunicationTimeRequestT = Model::UpdateCampaignCommunicationTimeRequest>
  void UpdateCampaignCommunicationTimeAsync(const UpdateCampaignCommunicationTimeRequestT& request,
                                            const UpdateCampaignCommunicationTimeResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignCommunicationTime, request, handler, context);
  }
 
  virtual Model::UpdateCampaignEntryLimitsOutcome UpdateCampaignEntryLimits(const Model::UpdateCampaignEntryLimitsRequest& request) const;
 
  template <typename UpdateCampaignEntryLimitsRequestT = Model::UpdateCampaignEntryLimitsRequest>
  Model::UpdateCampaignEntryLimitsOutcomeCallable UpdateCampaignEntryLimitsCallable(
      const UpdateCampaignEntryLimitsRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignEntryLimits, request);
  }
 
  template <typename UpdateCampaignEntryLimitsRequestT = Model::UpdateCampaignEntryLimitsRequest>
  void UpdateCampaignEntryLimitsAsync(const UpdateCampaignEntryLimitsRequestT& request,
                                      const UpdateCampaignEntryLimitsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignEntryLimits, request, handler, context);
  }
 
  virtual Model::UpdateCampaignFlowAssociationOutcome UpdateCampaignFlowAssociation(
      const Model::UpdateCampaignFlowAssociationRequest& request) const;
 
  template <typename UpdateCampaignFlowAssociationRequestT = Model::UpdateCampaignFlowAssociationRequest>
  Model::UpdateCampaignFlowAssociationOutcomeCallable UpdateCampaignFlowAssociationCallable(
      const UpdateCampaignFlowAssociationRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignFlowAssociation, request);
  }
 
  template <typename UpdateCampaignFlowAssociationRequestT = Model::UpdateCampaignFlowAssociationRequest>
  void UpdateCampaignFlowAssociationAsync(const UpdateCampaignFlowAssociationRequestT& request,
                                          const UpdateCampaignFlowAssociationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignFlowAssociation, request, handler, context);
  }
 
  virtual Model::UpdateCampaignNameOutcome UpdateCampaignName(const Model::UpdateCampaignNameRequest& request) const;
 
  template <typename UpdateCampaignNameRequestT = Model::UpdateCampaignNameRequest>
  Model::UpdateCampaignNameOutcomeCallable UpdateCampaignNameCallable(const UpdateCampaignNameRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignName, request);
  }
 
  template <typename UpdateCampaignNameRequestT = Model::UpdateCampaignNameRequest>
  void UpdateCampaignNameAsync(const UpdateCampaignNameRequestT& request, const UpdateCampaignNameResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignName, request, handler, context);
  }
 
  virtual Model::UpdateCampaignScheduleOutcome UpdateCampaignSchedule(const Model::UpdateCampaignScheduleRequest& request) const;
 
  template <typename UpdateCampaignScheduleRequestT = Model::UpdateCampaignScheduleRequest>
  Model::UpdateCampaignScheduleOutcomeCallable UpdateCampaignScheduleCallable(const UpdateCampaignScheduleRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignSchedule, request);
  }
 
  template <typename UpdateCampaignScheduleRequestT = Model::UpdateCampaignScheduleRequest>
  void UpdateCampaignScheduleAsync(const UpdateCampaignScheduleRequestT& request,
                                   const UpdateCampaignScheduleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignSchedule, request, handler, context);
  }
 
  virtual Model::UpdateCampaignSourceOutcome UpdateCampaignSource(const Model::UpdateCampaignSourceRequest& request) const;
 
  template <typename UpdateCampaignSourceRequestT = Model::UpdateCampaignSourceRequest>
  Model::UpdateCampaignSourceOutcomeCallable UpdateCampaignSourceCallable(const UpdateCampaignSourceRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsV2Client::UpdateCampaignSource, request);
  }
 
  template <typename UpdateCampaignSourceRequestT = Model::UpdateCampaignSourceRequest>
  void UpdateCampaignSourceAsync(const UpdateCampaignSourceRequestT& request, const UpdateCampaignSourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsV2Client::UpdateCampaignSource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ConnectCampaignsV2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectCampaignsV2Client>;
  void init(const ConnectCampaignsV2ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ConnectCampaignsV2Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ConnectCampaignsV2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<ConnectCampaignsV2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ConnectCampaignsV2
}  // namespace Aws