ConnectCampaignsClient.h

 
#pragma once
#include <aws/connectcampaigns/ConnectCampaignsPaginationBase.h>
#include <aws/connectcampaigns/ConnectCampaignsServiceClientModel.h>
#include <aws/connectcampaigns/ConnectCampaignsWaiter.h>
#include <aws/connectcampaigns/ConnectCampaigns_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 ConnectCampaigns {
class AWS_CONNECTCAMPAIGNS_API ConnectCampaignsClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<ConnectCampaignsClient>,
                                                        public ConnectCampaignsPaginationBase<ConnectCampaignsClient>,
                                                        public ConnectCampaignsWaiter<ConnectCampaignsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ConnectCampaignsClientConfiguration ClientConfigurationType;
  typedef ConnectCampaignsEndpointProvider EndpointProviderType;
 
  ConnectCampaignsClient(const Aws::ConnectCampaigns::ConnectCampaignsClientConfiguration& clientConfiguration =
                             Aws::ConnectCampaigns::ConnectCampaignsClientConfiguration(),
                         std::shared_ptr<ConnectCampaignsEndpointProviderBase> endpointProvider = nullptr);
 
  ConnectCampaignsClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<ConnectCampaignsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::ConnectCampaigns::ConnectCampaignsClientConfiguration& clientConfiguration =
                             Aws::ConnectCampaigns::ConnectCampaignsClientConfiguration());
 
  ConnectCampaignsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<ConnectCampaignsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::ConnectCampaigns::ConnectCampaignsClientConfiguration& clientConfiguration =
                             Aws::ConnectCampaigns::ConnectCampaignsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ConnectCampaignsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectCampaignsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ConnectCampaignsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ConnectCampaignsClient();
 
  virtual Model::CreateCampaignOutcome CreateCampaign(const Model::CreateCampaignRequest& request) const;
 
  template <typename CreateCampaignRequestT = Model::CreateCampaignRequest>
  Model::CreateCampaignOutcomeCallable CreateCampaignCallable(const CreateCampaignRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::DeleteCampaign, 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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::DeleteConnectInstanceConfig, 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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::GetConnectInstanceConfig, 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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::ListCampaigns, 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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::PauseCampaign, request, handler, context);
  }
 
  virtual Model::PutDialRequestBatchOutcome PutDialRequestBatch(const Model::PutDialRequestBatchRequest& request) const;
 
  template <typename PutDialRequestBatchRequestT = Model::PutDialRequestBatchRequest>
  Model::PutDialRequestBatchOutcomeCallable PutDialRequestBatchCallable(const PutDialRequestBatchRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsClient::PutDialRequestBatch, request);
  }
 
  template <typename PutDialRequestBatchRequestT = Model::PutDialRequestBatchRequest>
  void PutDialRequestBatchAsync(const PutDialRequestBatchRequestT& request, const PutDialRequestBatchResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsClient::PutDialRequestBatch, 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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCampaignDialerConfigOutcome UpdateCampaignDialerConfig(
      const Model::UpdateCampaignDialerConfigRequest& request) const;
 
  template <typename UpdateCampaignDialerConfigRequestT = Model::UpdateCampaignDialerConfigRequest>
  Model::UpdateCampaignDialerConfigOutcomeCallable UpdateCampaignDialerConfigCallable(
      const UpdateCampaignDialerConfigRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsClient::UpdateCampaignDialerConfig, request);
  }
 
  template <typename UpdateCampaignDialerConfigRequestT = Model::UpdateCampaignDialerConfigRequest>
  void UpdateCampaignDialerConfigAsync(const UpdateCampaignDialerConfigRequestT& request,
                                       const UpdateCampaignDialerConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsClient::UpdateCampaignDialerConfig, 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(&ConnectCampaignsClient::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(&ConnectCampaignsClient::UpdateCampaignName, request, handler, context);
  }
 
  virtual Model::UpdateCampaignOutboundCallConfigOutcome UpdateCampaignOutboundCallConfig(
      const Model::UpdateCampaignOutboundCallConfigRequest& request) const;
 
  template <typename UpdateCampaignOutboundCallConfigRequestT = Model::UpdateCampaignOutboundCallConfigRequest>
  Model::UpdateCampaignOutboundCallConfigOutcomeCallable UpdateCampaignOutboundCallConfigCallable(
      const UpdateCampaignOutboundCallConfigRequestT& request) const {
    return SubmitCallable(&ConnectCampaignsClient::UpdateCampaignOutboundCallConfig, request);
  }
 
  template <typename UpdateCampaignOutboundCallConfigRequestT = Model::UpdateCampaignOutboundCallConfigRequest>
  void UpdateCampaignOutboundCallConfigAsync(const UpdateCampaignOutboundCallConfigRequestT& request,
                                             const UpdateCampaignOutboundCallConfigResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ConnectCampaignsClient::UpdateCampaignOutboundCallConfig, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ConnectCampaignsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ConnectCampaignsClient>;
  void init(const ConnectCampaignsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ConnectCampaignsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ConnectCampaignsClientConfiguration m_clientConfiguration;
  std::shared_ptr<ConnectCampaignsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ConnectCampaigns
}  // namespace Aws