CodeGuruSecurityClient.h

 
#pragma once
#include <aws/codeguru-security/CodeGuruSecurityServiceClientModel.h>
#include <aws/codeguru-security/CodeGuruSecurity_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 CodeGuruSecurity {
class AWS_CODEGURUSECURITY_API CodeGuruSecurityClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<CodeGuruSecurityClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CodeGuruSecurityClientConfiguration ClientConfigurationType;
  typedef CodeGuruSecurityEndpointProvider EndpointProviderType;
 
  CodeGuruSecurityClient(const Aws::CodeGuruSecurity::CodeGuruSecurityClientConfiguration& clientConfiguration =
                             Aws::CodeGuruSecurity::CodeGuruSecurityClientConfiguration(),
                         std::shared_ptr<CodeGuruSecurityEndpointProviderBase> endpointProvider = nullptr);
 
  CodeGuruSecurityClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<CodeGuruSecurityEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::CodeGuruSecurity::CodeGuruSecurityClientConfiguration& clientConfiguration =
                             Aws::CodeGuruSecurity::CodeGuruSecurityClientConfiguration());
 
  CodeGuruSecurityClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<CodeGuruSecurityEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::CodeGuruSecurity::CodeGuruSecurityClientConfiguration& clientConfiguration =
                             Aws::CodeGuruSecurity::CodeGuruSecurityClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CodeGuruSecurityClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeGuruSecurityClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeGuruSecurityClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CodeGuruSecurityClient();
 
  virtual Model::BatchGetFindingsOutcome BatchGetFindings(const Model::BatchGetFindingsRequest& request) const;
 
  template <typename BatchGetFindingsRequestT = Model::BatchGetFindingsRequest>
  Model::BatchGetFindingsOutcomeCallable BatchGetFindingsCallable(const BatchGetFindingsRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::BatchGetFindings, request);
  }
 
  template <typename BatchGetFindingsRequestT = Model::BatchGetFindingsRequest>
  void BatchGetFindingsAsync(const BatchGetFindingsRequestT& request, const BatchGetFindingsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::BatchGetFindings, request, handler, context);
  }
 
  virtual Model::CreateScanOutcome CreateScan(const Model::CreateScanRequest& request) const;
 
  template <typename CreateScanRequestT = Model::CreateScanRequest>
  Model::CreateScanOutcomeCallable CreateScanCallable(const CreateScanRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::CreateScan, request);
  }
 
  template <typename CreateScanRequestT = Model::CreateScanRequest>
  void CreateScanAsync(const CreateScanRequestT& request, const CreateScanResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::CreateScan, request, handler, context);
  }
 
  virtual Model::CreateUploadUrlOutcome CreateUploadUrl(const Model::CreateUploadUrlRequest& request) const;
 
  template <typename CreateUploadUrlRequestT = Model::CreateUploadUrlRequest>
  Model::CreateUploadUrlOutcomeCallable CreateUploadUrlCallable(const CreateUploadUrlRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::CreateUploadUrl, request);
  }
 
  template <typename CreateUploadUrlRequestT = Model::CreateUploadUrlRequest>
  void CreateUploadUrlAsync(const CreateUploadUrlRequestT& request, const CreateUploadUrlResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::CreateUploadUrl, request, handler, context);
  }
 
  virtual Model::GetAccountConfigurationOutcome GetAccountConfiguration(const Model::GetAccountConfigurationRequest& request = {}) const;
 
  template <typename GetAccountConfigurationRequestT = Model::GetAccountConfigurationRequest>
  Model::GetAccountConfigurationOutcomeCallable GetAccountConfigurationCallable(const GetAccountConfigurationRequestT& request = {}) const {
    return SubmitCallable(&CodeGuruSecurityClient::GetAccountConfiguration, request);
  }
 
  template <typename GetAccountConfigurationRequestT = Model::GetAccountConfigurationRequest>
  void GetAccountConfigurationAsync(const GetAccountConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetAccountConfigurationRequestT& request = {}) const {
    return SubmitAsync(&CodeGuruSecurityClient::GetAccountConfiguration, request, handler, context);
  }
 
  virtual Model::GetFindingsOutcome GetFindings(const Model::GetFindingsRequest& request) const;
 
  template <typename GetFindingsRequestT = Model::GetFindingsRequest>
  Model::GetFindingsOutcomeCallable GetFindingsCallable(const GetFindingsRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::GetFindings, request);
  }
 
  template <typename GetFindingsRequestT = Model::GetFindingsRequest>
  void GetFindingsAsync(const GetFindingsRequestT& request, const GetFindingsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::GetFindings, request, handler, context);
  }
 
  virtual Model::GetMetricsSummaryOutcome GetMetricsSummary(const Model::GetMetricsSummaryRequest& request) const;
 
  template <typename GetMetricsSummaryRequestT = Model::GetMetricsSummaryRequest>
  Model::GetMetricsSummaryOutcomeCallable GetMetricsSummaryCallable(const GetMetricsSummaryRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::GetMetricsSummary, request);
  }
 
  template <typename GetMetricsSummaryRequestT = Model::GetMetricsSummaryRequest>
  void GetMetricsSummaryAsync(const GetMetricsSummaryRequestT& request, const GetMetricsSummaryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::GetMetricsSummary, request, handler, context);
  }
 
  virtual Model::GetScanOutcome GetScan(const Model::GetScanRequest& request) const;
 
  template <typename GetScanRequestT = Model::GetScanRequest>
  Model::GetScanOutcomeCallable GetScanCallable(const GetScanRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::GetScan, request);
  }
 
  template <typename GetScanRequestT = Model::GetScanRequest>
  void GetScanAsync(const GetScanRequestT& request, const GetScanResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::GetScan, request, handler, context);
  }
 
  virtual Model::ListFindingsMetricsOutcome ListFindingsMetrics(const Model::ListFindingsMetricsRequest& request) const;
 
  template <typename ListFindingsMetricsRequestT = Model::ListFindingsMetricsRequest>
  Model::ListFindingsMetricsOutcomeCallable ListFindingsMetricsCallable(const ListFindingsMetricsRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::ListFindingsMetrics, request);
  }
 
  template <typename ListFindingsMetricsRequestT = Model::ListFindingsMetricsRequest>
  void ListFindingsMetricsAsync(const ListFindingsMetricsRequestT& request, const ListFindingsMetricsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::ListFindingsMetrics, request, handler, context);
  }
 
  virtual Model::ListScansOutcome ListScans(const Model::ListScansRequest& request = {}) const;
 
  template <typename ListScansRequestT = Model::ListScansRequest>
  Model::ListScansOutcomeCallable ListScansCallable(const ListScansRequestT& request = {}) const {
    return SubmitCallable(&CodeGuruSecurityClient::ListScans, request);
  }
 
  template <typename ListScansRequestT = Model::ListScansRequest>
  void ListScansAsync(const ListScansResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListScansRequestT& request = {}) const {
    return SubmitAsync(&CodeGuruSecurityClient::ListScans, 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(&CodeGuruSecurityClient::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(&CodeGuruSecurityClient::ListTagsForResource, 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(&CodeGuruSecurityClient::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(&CodeGuruSecurityClient::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(&CodeGuruSecurityClient::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(&CodeGuruSecurityClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccountConfigurationOutcome UpdateAccountConfiguration(
      const Model::UpdateAccountConfigurationRequest& request) const;
 
  template <typename UpdateAccountConfigurationRequestT = Model::UpdateAccountConfigurationRequest>
  Model::UpdateAccountConfigurationOutcomeCallable UpdateAccountConfigurationCallable(
      const UpdateAccountConfigurationRequestT& request) const {
    return SubmitCallable(&CodeGuruSecurityClient::UpdateAccountConfiguration, request);
  }
 
  template <typename UpdateAccountConfigurationRequestT = Model::UpdateAccountConfigurationRequest>
  void UpdateAccountConfigurationAsync(const UpdateAccountConfigurationRequestT& request,
                                       const UpdateAccountConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeGuruSecurityClient::UpdateAccountConfiguration, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<CodeGuruSecurityEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeGuruSecurityClient>;
  void init(const CodeGuruSecurityClientConfiguration& clientConfiguration);
 
  CodeGuruSecurityClientConfiguration m_clientConfiguration;
  std::shared_ptr<CodeGuruSecurityEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CodeGuruSecurity
}  // namespace Aws