CodeStarNotificationsClient.h

 
#pragma once
#include <aws/codestar-notifications/CodeStarNotificationsPaginationBase.h>
#include <aws/codestar-notifications/CodeStarNotificationsServiceClientModel.h>
#include <aws/codestar-notifications/CodeStarNotificationsWaiter.h>
#include <aws/codestar-notifications/CodeStarNotifications_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 CodeStarNotifications {
class AWS_CODESTARNOTIFICATIONS_API CodeStarNotificationsClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<CodeStarNotificationsClient>,
      public CodeStarNotificationsPaginationBase<CodeStarNotificationsClient>,
      public CodeStarNotificationsWaiter<CodeStarNotificationsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CodeStarNotificationsClientConfiguration ClientConfigurationType;
  typedef CodeStarNotificationsEndpointProvider EndpointProviderType;
 
  CodeStarNotificationsClient(const Aws::CodeStarNotifications::CodeStarNotificationsClientConfiguration& clientConfiguration =
                                  Aws::CodeStarNotifications::CodeStarNotificationsClientConfiguration(),
                              std::shared_ptr<CodeStarNotificationsEndpointProviderBase> endpointProvider = nullptr);
 
  CodeStarNotificationsClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<CodeStarNotificationsEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::CodeStarNotifications::CodeStarNotificationsClientConfiguration& clientConfiguration =
                                  Aws::CodeStarNotifications::CodeStarNotificationsClientConfiguration());
 
  CodeStarNotificationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<CodeStarNotificationsEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::CodeStarNotifications::CodeStarNotificationsClientConfiguration& clientConfiguration =
                                  Aws::CodeStarNotifications::CodeStarNotificationsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CodeStarNotificationsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeStarNotificationsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeStarNotificationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CodeStarNotificationsClient();
 
  virtual Model::CreateNotificationRuleOutcome CreateNotificationRule(const Model::CreateNotificationRuleRequest& request) const;
 
  template <typename CreateNotificationRuleRequestT = Model::CreateNotificationRuleRequest>
  Model::CreateNotificationRuleOutcomeCallable CreateNotificationRuleCallable(const CreateNotificationRuleRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::CreateNotificationRule, request);
  }
 
  template <typename CreateNotificationRuleRequestT = Model::CreateNotificationRuleRequest>
  void CreateNotificationRuleAsync(const CreateNotificationRuleRequestT& request,
                                   const CreateNotificationRuleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::CreateNotificationRule, request, handler, context);
  }
 
  virtual Model::DeleteNotificationRuleOutcome DeleteNotificationRule(const Model::DeleteNotificationRuleRequest& request) const;
 
  template <typename DeleteNotificationRuleRequestT = Model::DeleteNotificationRuleRequest>
  Model::DeleteNotificationRuleOutcomeCallable DeleteNotificationRuleCallable(const DeleteNotificationRuleRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::DeleteNotificationRule, request);
  }
 
  template <typename DeleteNotificationRuleRequestT = Model::DeleteNotificationRuleRequest>
  void DeleteNotificationRuleAsync(const DeleteNotificationRuleRequestT& request,
                                   const DeleteNotificationRuleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::DeleteNotificationRule, request, handler, context);
  }
 
  virtual Model::DeleteTargetOutcome DeleteTarget(const Model::DeleteTargetRequest& request) const;
 
  template <typename DeleteTargetRequestT = Model::DeleteTargetRequest>
  Model::DeleteTargetOutcomeCallable DeleteTargetCallable(const DeleteTargetRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::DeleteTarget, request);
  }
 
  template <typename DeleteTargetRequestT = Model::DeleteTargetRequest>
  void DeleteTargetAsync(const DeleteTargetRequestT& request, const DeleteTargetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::DeleteTarget, request, handler, context);
  }
 
  virtual Model::DescribeNotificationRuleOutcome DescribeNotificationRule(const Model::DescribeNotificationRuleRequest& request) const;
 
  template <typename DescribeNotificationRuleRequestT = Model::DescribeNotificationRuleRequest>
  Model::DescribeNotificationRuleOutcomeCallable DescribeNotificationRuleCallable(const DescribeNotificationRuleRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::DescribeNotificationRule, request);
  }
 
  template <typename DescribeNotificationRuleRequestT = Model::DescribeNotificationRuleRequest>
  void DescribeNotificationRuleAsync(const DescribeNotificationRuleRequestT& request,
                                     const DescribeNotificationRuleResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::DescribeNotificationRule, request, handler, context);
  }
 
  virtual Model::ListEventTypesOutcome ListEventTypes(const Model::ListEventTypesRequest& request = {}) const;
 
  template <typename ListEventTypesRequestT = Model::ListEventTypesRequest>
  Model::ListEventTypesOutcomeCallable ListEventTypesCallable(const ListEventTypesRequestT& request = {}) const {
    return SubmitCallable(&CodeStarNotificationsClient::ListEventTypes, request);
  }
 
  template <typename ListEventTypesRequestT = Model::ListEventTypesRequest>
  void ListEventTypesAsync(const ListEventTypesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListEventTypesRequestT& request = {}) const {
    return SubmitAsync(&CodeStarNotificationsClient::ListEventTypes, request, handler, context);
  }
 
  virtual Model::ListNotificationRulesOutcome ListNotificationRules(const Model::ListNotificationRulesRequest& request = {}) const;
 
  template <typename ListNotificationRulesRequestT = Model::ListNotificationRulesRequest>
  Model::ListNotificationRulesOutcomeCallable ListNotificationRulesCallable(const ListNotificationRulesRequestT& request = {}) const {
    return SubmitCallable(&CodeStarNotificationsClient::ListNotificationRules, request);
  }
 
  template <typename ListNotificationRulesRequestT = Model::ListNotificationRulesRequest>
  void ListNotificationRulesAsync(const ListNotificationRulesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListNotificationRulesRequestT& request = {}) const {
    return SubmitAsync(&CodeStarNotificationsClient::ListNotificationRules, 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(&CodeStarNotificationsClient::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(&CodeStarNotificationsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTargetsOutcome ListTargets(const Model::ListTargetsRequest& request = {}) const;
 
  template <typename ListTargetsRequestT = Model::ListTargetsRequest>
  Model::ListTargetsOutcomeCallable ListTargetsCallable(const ListTargetsRequestT& request = {}) const {
    return SubmitCallable(&CodeStarNotificationsClient::ListTargets, request);
  }
 
  template <typename ListTargetsRequestT = Model::ListTargetsRequest>
  void ListTargetsAsync(const ListTargetsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListTargetsRequestT& request = {}) const {
    return SubmitAsync(&CodeStarNotificationsClient::ListTargets, request, handler, context);
  }
 
  virtual Model::SubscribeOutcome Subscribe(const Model::SubscribeRequest& request) const;
 
  template <typename SubscribeRequestT = Model::SubscribeRequest>
  Model::SubscribeOutcomeCallable SubscribeCallable(const SubscribeRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::Subscribe, request);
  }
 
  template <typename SubscribeRequestT = Model::SubscribeRequest>
  void SubscribeAsync(const SubscribeRequestT& request, const SubscribeResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::Subscribe, 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(&CodeStarNotificationsClient::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(&CodeStarNotificationsClient::TagResource, request, handler, context);
  }
 
  virtual Model::UnsubscribeOutcome Unsubscribe(const Model::UnsubscribeRequest& request) const;
 
  template <typename UnsubscribeRequestT = Model::UnsubscribeRequest>
  Model::UnsubscribeOutcomeCallable UnsubscribeCallable(const UnsubscribeRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::Unsubscribe, request);
  }
 
  template <typename UnsubscribeRequestT = Model::UnsubscribeRequest>
  void UnsubscribeAsync(const UnsubscribeRequestT& request, const UnsubscribeResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::Unsubscribe, 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(&CodeStarNotificationsClient::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(&CodeStarNotificationsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateNotificationRuleOutcome UpdateNotificationRule(const Model::UpdateNotificationRuleRequest& request) const;
 
  template <typename UpdateNotificationRuleRequestT = Model::UpdateNotificationRuleRequest>
  Model::UpdateNotificationRuleOutcomeCallable UpdateNotificationRuleCallable(const UpdateNotificationRuleRequestT& request) const {
    return SubmitCallable(&CodeStarNotificationsClient::UpdateNotificationRule, request);
  }
 
  template <typename UpdateNotificationRuleRequestT = Model::UpdateNotificationRuleRequest>
  void UpdateNotificationRuleAsync(const UpdateNotificationRuleRequestT& request,
                                   const UpdateNotificationRuleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeStarNotificationsClient::UpdateNotificationRule, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CodeStarNotificationsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeStarNotificationsClient>;
  void init(const CodeStarNotificationsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CodeStarNotificationsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  CodeStarNotificationsClientConfiguration m_clientConfiguration;
  std::shared_ptr<CodeStarNotificationsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CodeStarNotifications
}  // namespace Aws