ConnectCampaignsV2Client.h

 
#pragma once
#include <aws/connectcampaignsv2/ConnectCampaignsV2_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/connectcampaignsv2/ConnectCampaignsV2ServiceClientModel.h>
 
namespace Aws
{
namespace ConnectCampaignsV2
{
  class AWS_CONNECTCAMPAIGNSV2_API ConnectCampaignsV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ConnectCampaignsV2EndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectCampaignsV2Client>;
      void init(const ConnectCampaignsV2ClientConfiguration& clientConfiguration);
 
      ConnectCampaignsV2ClientConfiguration m_clientConfiguration;
      std::shared_ptr<ConnectCampaignsV2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ConnectCampaignsV2
} // namespace Aws