CodeGuruSecurityClient.h

 
#pragma once
#include <aws/codeguru-security/CodeGuruSecurity_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/codeguru-security/CodeGuruSecurityServiceClientModel.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