Inspector2Client.h

 
#pragma once
#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>
#include <aws/inspector2/Inspector2PaginationBase.h>
#include <aws/inspector2/Inspector2ServiceClientModel.h>
#include <aws/inspector2/Inspector2Waiter.h>
#include <aws/inspector2/Inspector2_EXPORTS.h>
 
namespace Aws {
namespace Inspector2 {
class AWS_INSPECTOR2_API Inspector2Client : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<Inspector2Client>,
                                            public Inspector2PaginationBase<Inspector2Client>,
                                            public Inspector2Waiter<Inspector2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Inspector2ClientConfiguration ClientConfigurationType;
  typedef Inspector2EndpointProvider EndpointProviderType;
 
  Inspector2Client(
      const Aws::Inspector2::Inspector2ClientConfiguration& clientConfiguration = Aws::Inspector2::Inspector2ClientConfiguration(),
      std::shared_ptr<Inspector2EndpointProviderBase> endpointProvider = nullptr);
 
  Inspector2Client(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<Inspector2EndpointProviderBase> endpointProvider = nullptr,
      const Aws::Inspector2::Inspector2ClientConfiguration& clientConfiguration = Aws::Inspector2::Inspector2ClientConfiguration());
 
  Inspector2Client(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<Inspector2EndpointProviderBase> endpointProvider = nullptr,
      const Aws::Inspector2::Inspector2ClientConfiguration& clientConfiguration = Aws::Inspector2::Inspector2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Inspector2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Inspector2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Inspector2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Inspector2Client();
 
  virtual Model::AssociateMemberOutcome AssociateMember(const Model::AssociateMemberRequest& request) const;
 
  template <typename AssociateMemberRequestT = Model::AssociateMemberRequest>
  Model::AssociateMemberOutcomeCallable AssociateMemberCallable(const AssociateMemberRequestT& request) const {
    return SubmitCallable(&Inspector2Client::AssociateMember, request);
  }
 
  template <typename AssociateMemberRequestT = Model::AssociateMemberRequest>
  void AssociateMemberAsync(const AssociateMemberRequestT& request, const AssociateMemberResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::AssociateMember, request, handler, context);
  }
 
  virtual Model::BatchAssociateCodeSecurityScanConfigurationOutcome BatchAssociateCodeSecurityScanConfiguration(
      const Model::BatchAssociateCodeSecurityScanConfigurationRequest& request) const;
 
  template <typename BatchAssociateCodeSecurityScanConfigurationRequestT = Model::BatchAssociateCodeSecurityScanConfigurationRequest>
  Model::BatchAssociateCodeSecurityScanConfigurationOutcomeCallable BatchAssociateCodeSecurityScanConfigurationCallable(
      const BatchAssociateCodeSecurityScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::BatchAssociateCodeSecurityScanConfiguration, request);
  }
 
  template <typename BatchAssociateCodeSecurityScanConfigurationRequestT = Model::BatchAssociateCodeSecurityScanConfigurationRequest>
  void BatchAssociateCodeSecurityScanConfigurationAsync(
      const BatchAssociateCodeSecurityScanConfigurationRequestT& request,
      const BatchAssociateCodeSecurityScanConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::BatchAssociateCodeSecurityScanConfiguration, request, handler, context);
  }
 
  virtual Model::BatchDisassociateCodeSecurityScanConfigurationOutcome BatchDisassociateCodeSecurityScanConfiguration(
      const Model::BatchDisassociateCodeSecurityScanConfigurationRequest& request) const;
 
  template <typename BatchDisassociateCodeSecurityScanConfigurationRequestT = Model::BatchDisassociateCodeSecurityScanConfigurationRequest>
  Model::BatchDisassociateCodeSecurityScanConfigurationOutcomeCallable BatchDisassociateCodeSecurityScanConfigurationCallable(
      const BatchDisassociateCodeSecurityScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::BatchDisassociateCodeSecurityScanConfiguration, request);
  }
 
  template <typename BatchDisassociateCodeSecurityScanConfigurationRequestT = Model::BatchDisassociateCodeSecurityScanConfigurationRequest>
  void BatchDisassociateCodeSecurityScanConfigurationAsync(
      const BatchDisassociateCodeSecurityScanConfigurationRequestT& request,
      const BatchDisassociateCodeSecurityScanConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::BatchDisassociateCodeSecurityScanConfiguration, request, handler, context);
  }
 
  virtual Model::BatchGetAccountStatusOutcome BatchGetAccountStatus(const Model::BatchGetAccountStatusRequest& request = {}) const;
 
  template <typename BatchGetAccountStatusRequestT = Model::BatchGetAccountStatusRequest>
  Model::BatchGetAccountStatusOutcomeCallable BatchGetAccountStatusCallable(const BatchGetAccountStatusRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::BatchGetAccountStatus, request);
  }
 
  template <typename BatchGetAccountStatusRequestT = Model::BatchGetAccountStatusRequest>
  void BatchGetAccountStatusAsync(const BatchGetAccountStatusResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const BatchGetAccountStatusRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::BatchGetAccountStatus, request, handler, context);
  }
 
  virtual Model::BatchGetCodeSnippetOutcome BatchGetCodeSnippet(const Model::BatchGetCodeSnippetRequest& request) const;
 
  template <typename BatchGetCodeSnippetRequestT = Model::BatchGetCodeSnippetRequest>
  Model::BatchGetCodeSnippetOutcomeCallable BatchGetCodeSnippetCallable(const BatchGetCodeSnippetRequestT& request) const {
    return SubmitCallable(&Inspector2Client::BatchGetCodeSnippet, request);
  }
 
  template <typename BatchGetCodeSnippetRequestT = Model::BatchGetCodeSnippetRequest>
  void BatchGetCodeSnippetAsync(const BatchGetCodeSnippetRequestT& request, const BatchGetCodeSnippetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::BatchGetCodeSnippet, request, handler, context);
  }
 
  virtual Model::BatchGetFindingDetailsOutcome BatchGetFindingDetails(const Model::BatchGetFindingDetailsRequest& request) const;
 
  template <typename BatchGetFindingDetailsRequestT = Model::BatchGetFindingDetailsRequest>
  Model::BatchGetFindingDetailsOutcomeCallable BatchGetFindingDetailsCallable(const BatchGetFindingDetailsRequestT& request) const {
    return SubmitCallable(&Inspector2Client::BatchGetFindingDetails, request);
  }
 
  template <typename BatchGetFindingDetailsRequestT = Model::BatchGetFindingDetailsRequest>
  void BatchGetFindingDetailsAsync(const BatchGetFindingDetailsRequestT& request,
                                   const BatchGetFindingDetailsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::BatchGetFindingDetails, request, handler, context);
  }
 
  virtual Model::BatchGetFreeTrialInfoOutcome BatchGetFreeTrialInfo(const Model::BatchGetFreeTrialInfoRequest& request) const;
 
  template <typename BatchGetFreeTrialInfoRequestT = Model::BatchGetFreeTrialInfoRequest>
  Model::BatchGetFreeTrialInfoOutcomeCallable BatchGetFreeTrialInfoCallable(const BatchGetFreeTrialInfoRequestT& request) const {
    return SubmitCallable(&Inspector2Client::BatchGetFreeTrialInfo, request);
  }
 
  template <typename BatchGetFreeTrialInfoRequestT = Model::BatchGetFreeTrialInfoRequest>
  void BatchGetFreeTrialInfoAsync(const BatchGetFreeTrialInfoRequestT& request, const BatchGetFreeTrialInfoResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::BatchGetFreeTrialInfo, request, handler, context);
  }
 
  virtual Model::BatchGetMemberEc2DeepInspectionStatusOutcome BatchGetMemberEc2DeepInspectionStatus(
      const Model::BatchGetMemberEc2DeepInspectionStatusRequest& request = {}) const;
 
  template <typename BatchGetMemberEc2DeepInspectionStatusRequestT = Model::BatchGetMemberEc2DeepInspectionStatusRequest>
  Model::BatchGetMemberEc2DeepInspectionStatusOutcomeCallable BatchGetMemberEc2DeepInspectionStatusCallable(
      const BatchGetMemberEc2DeepInspectionStatusRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::BatchGetMemberEc2DeepInspectionStatus, request);
  }
 
  template <typename BatchGetMemberEc2DeepInspectionStatusRequestT = Model::BatchGetMemberEc2DeepInspectionStatusRequest>
  void BatchGetMemberEc2DeepInspectionStatusAsync(const BatchGetMemberEc2DeepInspectionStatusResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const BatchGetMemberEc2DeepInspectionStatusRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::BatchGetMemberEc2DeepInspectionStatus, request, handler, context);
  }
 
  virtual Model::BatchUpdateMemberEc2DeepInspectionStatusOutcome BatchUpdateMemberEc2DeepInspectionStatus(
      const Model::BatchUpdateMemberEc2DeepInspectionStatusRequest& request) const;
 
  template <typename BatchUpdateMemberEc2DeepInspectionStatusRequestT = Model::BatchUpdateMemberEc2DeepInspectionStatusRequest>
  Model::BatchUpdateMemberEc2DeepInspectionStatusOutcomeCallable BatchUpdateMemberEc2DeepInspectionStatusCallable(
      const BatchUpdateMemberEc2DeepInspectionStatusRequestT& request) const {
    return SubmitCallable(&Inspector2Client::BatchUpdateMemberEc2DeepInspectionStatus, request);
  }
 
  template <typename BatchUpdateMemberEc2DeepInspectionStatusRequestT = Model::BatchUpdateMemberEc2DeepInspectionStatusRequest>
  void BatchUpdateMemberEc2DeepInspectionStatusAsync(
      const BatchUpdateMemberEc2DeepInspectionStatusRequestT& request,
      const BatchUpdateMemberEc2DeepInspectionStatusResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::BatchUpdateMemberEc2DeepInspectionStatus, request, handler, context);
  }
 
  virtual Model::CancelFindingsReportOutcome CancelFindingsReport(const Model::CancelFindingsReportRequest& request) const;
 
  template <typename CancelFindingsReportRequestT = Model::CancelFindingsReportRequest>
  Model::CancelFindingsReportOutcomeCallable CancelFindingsReportCallable(const CancelFindingsReportRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CancelFindingsReport, request);
  }
 
  template <typename CancelFindingsReportRequestT = Model::CancelFindingsReportRequest>
  void CancelFindingsReportAsync(const CancelFindingsReportRequestT& request, const CancelFindingsReportResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CancelFindingsReport, request, handler, context);
  }
 
  virtual Model::CancelSbomExportOutcome CancelSbomExport(const Model::CancelSbomExportRequest& request) const;
 
  template <typename CancelSbomExportRequestT = Model::CancelSbomExportRequest>
  Model::CancelSbomExportOutcomeCallable CancelSbomExportCallable(const CancelSbomExportRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CancelSbomExport, request);
  }
 
  template <typename CancelSbomExportRequestT = Model::CancelSbomExportRequest>
  void CancelSbomExportAsync(const CancelSbomExportRequestT& request, const CancelSbomExportResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CancelSbomExport, request, handler, context);
  }
 
  virtual Model::CreateCisScanConfigurationOutcome CreateCisScanConfiguration(
      const Model::CreateCisScanConfigurationRequest& request) const;
 
  template <typename CreateCisScanConfigurationRequestT = Model::CreateCisScanConfigurationRequest>
  Model::CreateCisScanConfigurationOutcomeCallable CreateCisScanConfigurationCallable(
      const CreateCisScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateCisScanConfiguration, request);
  }
 
  template <typename CreateCisScanConfigurationRequestT = Model::CreateCisScanConfigurationRequest>
  void CreateCisScanConfigurationAsync(const CreateCisScanConfigurationRequestT& request,
                                       const CreateCisScanConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateCisScanConfiguration, request, handler, context);
  }
 
  virtual Model::CreateCodeSecurityIntegrationOutcome CreateCodeSecurityIntegration(
      const Model::CreateCodeSecurityIntegrationRequest& request) const;
 
  template <typename CreateCodeSecurityIntegrationRequestT = Model::CreateCodeSecurityIntegrationRequest>
  Model::CreateCodeSecurityIntegrationOutcomeCallable CreateCodeSecurityIntegrationCallable(
      const CreateCodeSecurityIntegrationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateCodeSecurityIntegration, request);
  }
 
  template <typename CreateCodeSecurityIntegrationRequestT = Model::CreateCodeSecurityIntegrationRequest>
  void CreateCodeSecurityIntegrationAsync(const CreateCodeSecurityIntegrationRequestT& request,
                                          const CreateCodeSecurityIntegrationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateCodeSecurityIntegration, request, handler, context);
  }
 
  virtual Model::CreateCodeSecurityScanConfigurationOutcome CreateCodeSecurityScanConfiguration(
      const Model::CreateCodeSecurityScanConfigurationRequest& request) const;
 
  template <typename CreateCodeSecurityScanConfigurationRequestT = Model::CreateCodeSecurityScanConfigurationRequest>
  Model::CreateCodeSecurityScanConfigurationOutcomeCallable CreateCodeSecurityScanConfigurationCallable(
      const CreateCodeSecurityScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateCodeSecurityScanConfiguration, request);
  }
 
  template <typename CreateCodeSecurityScanConfigurationRequestT = Model::CreateCodeSecurityScanConfigurationRequest>
  void CreateCodeSecurityScanConfigurationAsync(const CreateCodeSecurityScanConfigurationRequestT& request,
                                                const CreateCodeSecurityScanConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateCodeSecurityScanConfiguration, request, handler, context);
  }
 
  virtual Model::CreateConnectorOutcome CreateConnector(const Model::CreateConnectorRequest& request) const;
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  Model::CreateConnectorOutcomeCallable CreateConnectorCallable(const CreateConnectorRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateConnector, request);
  }
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  void CreateConnectorAsync(const CreateConnectorRequestT& request, const CreateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateConnector, request, handler, context);
  }
 
  virtual Model::CreateFilterOutcome CreateFilter(const Model::CreateFilterRequest& request) const;
 
  template <typename CreateFilterRequestT = Model::CreateFilterRequest>
  Model::CreateFilterOutcomeCallable CreateFilterCallable(const CreateFilterRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateFilter, request);
  }
 
  template <typename CreateFilterRequestT = Model::CreateFilterRequest>
  void CreateFilterAsync(const CreateFilterRequestT& request, const CreateFilterResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateFilter, request, handler, context);
  }
 
  virtual Model::CreateFindingsReportOutcome CreateFindingsReport(const Model::CreateFindingsReportRequest& request) const;
 
  template <typename CreateFindingsReportRequestT = Model::CreateFindingsReportRequest>
  Model::CreateFindingsReportOutcomeCallable CreateFindingsReportCallable(const CreateFindingsReportRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateFindingsReport, request);
  }
 
  template <typename CreateFindingsReportRequestT = Model::CreateFindingsReportRequest>
  void CreateFindingsReportAsync(const CreateFindingsReportRequestT& request, const CreateFindingsReportResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateFindingsReport, request, handler, context);
  }
 
  virtual Model::CreateSbomExportOutcome CreateSbomExport(const Model::CreateSbomExportRequest& request) const;
 
  template <typename CreateSbomExportRequestT = Model::CreateSbomExportRequest>
  Model::CreateSbomExportOutcomeCallable CreateSbomExportCallable(const CreateSbomExportRequestT& request) const {
    return SubmitCallable(&Inspector2Client::CreateSbomExport, request);
  }
 
  template <typename CreateSbomExportRequestT = Model::CreateSbomExportRequest>
  void CreateSbomExportAsync(const CreateSbomExportRequestT& request, const CreateSbomExportResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::CreateSbomExport, request, handler, context);
  }
 
  virtual Model::DeleteCisScanConfigurationOutcome DeleteCisScanConfiguration(
      const Model::DeleteCisScanConfigurationRequest& request) const;
 
  template <typename DeleteCisScanConfigurationRequestT = Model::DeleteCisScanConfigurationRequest>
  Model::DeleteCisScanConfigurationOutcomeCallable DeleteCisScanConfigurationCallable(
      const DeleteCisScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DeleteCisScanConfiguration, request);
  }
 
  template <typename DeleteCisScanConfigurationRequestT = Model::DeleteCisScanConfigurationRequest>
  void DeleteCisScanConfigurationAsync(const DeleteCisScanConfigurationRequestT& request,
                                       const DeleteCisScanConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DeleteCisScanConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteCodeSecurityIntegrationOutcome DeleteCodeSecurityIntegration(
      const Model::DeleteCodeSecurityIntegrationRequest& request) const;
 
  template <typename DeleteCodeSecurityIntegrationRequestT = Model::DeleteCodeSecurityIntegrationRequest>
  Model::DeleteCodeSecurityIntegrationOutcomeCallable DeleteCodeSecurityIntegrationCallable(
      const DeleteCodeSecurityIntegrationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DeleteCodeSecurityIntegration, request);
  }
 
  template <typename DeleteCodeSecurityIntegrationRequestT = Model::DeleteCodeSecurityIntegrationRequest>
  void DeleteCodeSecurityIntegrationAsync(const DeleteCodeSecurityIntegrationRequestT& request,
                                          const DeleteCodeSecurityIntegrationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DeleteCodeSecurityIntegration, request, handler, context);
  }
 
  virtual Model::DeleteCodeSecurityScanConfigurationOutcome DeleteCodeSecurityScanConfiguration(
      const Model::DeleteCodeSecurityScanConfigurationRequest& request) const;
 
  template <typename DeleteCodeSecurityScanConfigurationRequestT = Model::DeleteCodeSecurityScanConfigurationRequest>
  Model::DeleteCodeSecurityScanConfigurationOutcomeCallable DeleteCodeSecurityScanConfigurationCallable(
      const DeleteCodeSecurityScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DeleteCodeSecurityScanConfiguration, request);
  }
 
  template <typename DeleteCodeSecurityScanConfigurationRequestT = Model::DeleteCodeSecurityScanConfigurationRequest>
  void DeleteCodeSecurityScanConfigurationAsync(const DeleteCodeSecurityScanConfigurationRequestT& request,
                                                const DeleteCodeSecurityScanConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DeleteCodeSecurityScanConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteConnectorOutcome DeleteConnector(const Model::DeleteConnectorRequest& request) const;
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  Model::DeleteConnectorOutcomeCallable DeleteConnectorCallable(const DeleteConnectorRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DeleteConnector, request);
  }
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  void DeleteConnectorAsync(const DeleteConnectorRequestT& request, const DeleteConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DeleteConnector, request, handler, context);
  }
 
  virtual Model::DeleteFilterOutcome DeleteFilter(const Model::DeleteFilterRequest& request) const;
 
  template <typename DeleteFilterRequestT = Model::DeleteFilterRequest>
  Model::DeleteFilterOutcomeCallable DeleteFilterCallable(const DeleteFilterRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DeleteFilter, request);
  }
 
  template <typename DeleteFilterRequestT = Model::DeleteFilterRequest>
  void DeleteFilterAsync(const DeleteFilterRequestT& request, const DeleteFilterResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DeleteFilter, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationConfigurationOutcome DescribeOrganizationConfiguration(
      const Model::DescribeOrganizationConfigurationRequest& request = {}) const;
 
  template <typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
  Model::DescribeOrganizationConfigurationOutcomeCallable DescribeOrganizationConfigurationCallable(
      const DescribeOrganizationConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::DescribeOrganizationConfiguration, request);
  }
 
  template <typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
  void DescribeOrganizationConfigurationAsync(const DescribeOrganizationConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeOrganizationConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::DescribeOrganizationConfiguration, request, handler, context);
  }
 
  virtual Model::DisableOutcome Disable(const Model::DisableRequest& request = {}) const;
 
  template <typename DisableRequestT = Model::DisableRequest>
  Model::DisableOutcomeCallable DisableCallable(const DisableRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::Disable, request);
  }
 
  template <typename DisableRequestT = Model::DisableRequest>
  void DisableAsync(const DisableResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                    const DisableRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::Disable, request, handler, context);
  }
 
  virtual Model::DisableDelegatedAdminAccountOutcome DisableDelegatedAdminAccount(
      const Model::DisableDelegatedAdminAccountRequest& request) const;
 
  template <typename DisableDelegatedAdminAccountRequestT = Model::DisableDelegatedAdminAccountRequest>
  Model::DisableDelegatedAdminAccountOutcomeCallable DisableDelegatedAdminAccountCallable(
      const DisableDelegatedAdminAccountRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DisableDelegatedAdminAccount, request);
  }
 
  template <typename DisableDelegatedAdminAccountRequestT = Model::DisableDelegatedAdminAccountRequest>
  void DisableDelegatedAdminAccountAsync(const DisableDelegatedAdminAccountRequestT& request,
                                         const DisableDelegatedAdminAccountResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DisableDelegatedAdminAccount, request, handler, context);
  }
 
  virtual Model::DisassociateMemberOutcome DisassociateMember(const Model::DisassociateMemberRequest& request) const;
 
  template <typename DisassociateMemberRequestT = Model::DisassociateMemberRequest>
  Model::DisassociateMemberOutcomeCallable DisassociateMemberCallable(const DisassociateMemberRequestT& request) const {
    return SubmitCallable(&Inspector2Client::DisassociateMember, request);
  }
 
  template <typename DisassociateMemberRequestT = Model::DisassociateMemberRequest>
  void DisassociateMemberAsync(const DisassociateMemberRequestT& request, const DisassociateMemberResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::DisassociateMember, request, handler, context);
  }
 
  virtual Model::EnableOutcome Enable(const Model::EnableRequest& request) const;
 
  template <typename EnableRequestT = Model::EnableRequest>
  Model::EnableOutcomeCallable EnableCallable(const EnableRequestT& request) const {
    return SubmitCallable(&Inspector2Client::Enable, request);
  }
 
  template <typename EnableRequestT = Model::EnableRequest>
  void EnableAsync(const EnableRequestT& request, const EnableResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::Enable, request, handler, context);
  }
 
  virtual Model::EnableDelegatedAdminAccountOutcome EnableDelegatedAdminAccount(
      const Model::EnableDelegatedAdminAccountRequest& request) const;
 
  template <typename EnableDelegatedAdminAccountRequestT = Model::EnableDelegatedAdminAccountRequest>
  Model::EnableDelegatedAdminAccountOutcomeCallable EnableDelegatedAdminAccountCallable(
      const EnableDelegatedAdminAccountRequestT& request) const {
    return SubmitCallable(&Inspector2Client::EnableDelegatedAdminAccount, request);
  }
 
  template <typename EnableDelegatedAdminAccountRequestT = Model::EnableDelegatedAdminAccountRequest>
  void EnableDelegatedAdminAccountAsync(const EnableDelegatedAdminAccountRequestT& request,
                                        const EnableDelegatedAdminAccountResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::EnableDelegatedAdminAccount, request, handler, context);
  }
 
  virtual Model::GetCisScanReportOutcome GetCisScanReport(const Model::GetCisScanReportRequest& request) const;
 
  template <typename GetCisScanReportRequestT = Model::GetCisScanReportRequest>
  Model::GetCisScanReportOutcomeCallable GetCisScanReportCallable(const GetCisScanReportRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetCisScanReport, request);
  }
 
  template <typename GetCisScanReportRequestT = Model::GetCisScanReportRequest>
  void GetCisScanReportAsync(const GetCisScanReportRequestT& request, const GetCisScanReportResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetCisScanReport, request, handler, context);
  }
 
  virtual Model::GetCisScanResultDetailsOutcome GetCisScanResultDetails(const Model::GetCisScanResultDetailsRequest& request) const;
 
  template <typename GetCisScanResultDetailsRequestT = Model::GetCisScanResultDetailsRequest>
  Model::GetCisScanResultDetailsOutcomeCallable GetCisScanResultDetailsCallable(const GetCisScanResultDetailsRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetCisScanResultDetails, request);
  }
 
  template <typename GetCisScanResultDetailsRequestT = Model::GetCisScanResultDetailsRequest>
  void GetCisScanResultDetailsAsync(const GetCisScanResultDetailsRequestT& request,
                                    const GetCisScanResultDetailsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetCisScanResultDetails, request, handler, context);
  }
 
  virtual Model::GetClustersForImageOutcome GetClustersForImage(const Model::GetClustersForImageRequest& request) const;
 
  template <typename GetClustersForImageRequestT = Model::GetClustersForImageRequest>
  Model::GetClustersForImageOutcomeCallable GetClustersForImageCallable(const GetClustersForImageRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetClustersForImage, request);
  }
 
  template <typename GetClustersForImageRequestT = Model::GetClustersForImageRequest>
  void GetClustersForImageAsync(const GetClustersForImageRequestT& request, const GetClustersForImageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetClustersForImage, request, handler, context);
  }
 
  virtual Model::GetCodeSecurityIntegrationOutcome GetCodeSecurityIntegration(
      const Model::GetCodeSecurityIntegrationRequest& request) const;
 
  template <typename GetCodeSecurityIntegrationRequestT = Model::GetCodeSecurityIntegrationRequest>
  Model::GetCodeSecurityIntegrationOutcomeCallable GetCodeSecurityIntegrationCallable(
      const GetCodeSecurityIntegrationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetCodeSecurityIntegration, request);
  }
 
  template <typename GetCodeSecurityIntegrationRequestT = Model::GetCodeSecurityIntegrationRequest>
  void GetCodeSecurityIntegrationAsync(const GetCodeSecurityIntegrationRequestT& request,
                                       const GetCodeSecurityIntegrationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetCodeSecurityIntegration, request, handler, context);
  }
 
  virtual Model::GetCodeSecurityScanOutcome GetCodeSecurityScan(const Model::GetCodeSecurityScanRequest& request) const;
 
  template <typename GetCodeSecurityScanRequestT = Model::GetCodeSecurityScanRequest>
  Model::GetCodeSecurityScanOutcomeCallable GetCodeSecurityScanCallable(const GetCodeSecurityScanRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetCodeSecurityScan, request);
  }
 
  template <typename GetCodeSecurityScanRequestT = Model::GetCodeSecurityScanRequest>
  void GetCodeSecurityScanAsync(const GetCodeSecurityScanRequestT& request, const GetCodeSecurityScanResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetCodeSecurityScan, request, handler, context);
  }
 
  virtual Model::GetCodeSecurityScanConfigurationOutcome GetCodeSecurityScanConfiguration(
      const Model::GetCodeSecurityScanConfigurationRequest& request) const;
 
  template <typename GetCodeSecurityScanConfigurationRequestT = Model::GetCodeSecurityScanConfigurationRequest>
  Model::GetCodeSecurityScanConfigurationOutcomeCallable GetCodeSecurityScanConfigurationCallable(
      const GetCodeSecurityScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetCodeSecurityScanConfiguration, request);
  }
 
  template <typename GetCodeSecurityScanConfigurationRequestT = Model::GetCodeSecurityScanConfigurationRequest>
  void GetCodeSecurityScanConfigurationAsync(const GetCodeSecurityScanConfigurationRequestT& request,
                                             const GetCodeSecurityScanConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetCodeSecurityScanConfiguration, request, handler, context);
  }
 
  virtual Model::GetConfigurationOutcome GetConfiguration(const Model::GetConfigurationRequest& request = {}) const;
 
  template <typename GetConfigurationRequestT = Model::GetConfigurationRequest>
  Model::GetConfigurationOutcomeCallable GetConfigurationCallable(const GetConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::GetConfiguration, request);
  }
 
  template <typename GetConfigurationRequestT = Model::GetConfigurationRequest>
  void GetConfigurationAsync(const GetConfigurationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::GetConfiguration, request, handler, context);
  }
 
  virtual Model::GetDelegatedAdminAccountOutcome GetDelegatedAdminAccount(const Model::GetDelegatedAdminAccountRequest& request = {}) const;
 
  template <typename GetDelegatedAdminAccountRequestT = Model::GetDelegatedAdminAccountRequest>
  Model::GetDelegatedAdminAccountOutcomeCallable GetDelegatedAdminAccountCallable(
      const GetDelegatedAdminAccountRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::GetDelegatedAdminAccount, request);
  }
 
  template <typename GetDelegatedAdminAccountRequestT = Model::GetDelegatedAdminAccountRequest>
  void GetDelegatedAdminAccountAsync(const GetDelegatedAdminAccountResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const GetDelegatedAdminAccountRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::GetDelegatedAdminAccount, request, handler, context);
  }
 
  virtual Model::GetEc2DeepInspectionConfigurationOutcome GetEc2DeepInspectionConfiguration(
      const Model::GetEc2DeepInspectionConfigurationRequest& request = {}) const;
 
  template <typename GetEc2DeepInspectionConfigurationRequestT = Model::GetEc2DeepInspectionConfigurationRequest>
  Model::GetEc2DeepInspectionConfigurationOutcomeCallable GetEc2DeepInspectionConfigurationCallable(
      const GetEc2DeepInspectionConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::GetEc2DeepInspectionConfiguration, request);
  }
 
  template <typename GetEc2DeepInspectionConfigurationRequestT = Model::GetEc2DeepInspectionConfigurationRequest>
  void GetEc2DeepInspectionConfigurationAsync(const GetEc2DeepInspectionConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const GetEc2DeepInspectionConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::GetEc2DeepInspectionConfiguration, request, handler, context);
  }
 
  virtual Model::GetEncryptionKeyOutcome GetEncryptionKey(const Model::GetEncryptionKeyRequest& request) const;
 
  template <typename GetEncryptionKeyRequestT = Model::GetEncryptionKeyRequest>
  Model::GetEncryptionKeyOutcomeCallable GetEncryptionKeyCallable(const GetEncryptionKeyRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetEncryptionKey, request);
  }
 
  template <typename GetEncryptionKeyRequestT = Model::GetEncryptionKeyRequest>
  void GetEncryptionKeyAsync(const GetEncryptionKeyRequestT& request, const GetEncryptionKeyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetEncryptionKey, request, handler, context);
  }
 
  virtual Model::GetFindingsReportStatusOutcome GetFindingsReportStatus(const Model::GetFindingsReportStatusRequest& request = {}) const;
 
  template <typename GetFindingsReportStatusRequestT = Model::GetFindingsReportStatusRequest>
  Model::GetFindingsReportStatusOutcomeCallable GetFindingsReportStatusCallable(const GetFindingsReportStatusRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::GetFindingsReportStatus, request);
  }
 
  template <typename GetFindingsReportStatusRequestT = Model::GetFindingsReportStatusRequest>
  void GetFindingsReportStatusAsync(const GetFindingsReportStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetFindingsReportStatusRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::GetFindingsReportStatus, request, handler, context);
  }
 
  virtual Model::GetMemberOutcome GetMember(const Model::GetMemberRequest& request) const;
 
  template <typename GetMemberRequestT = Model::GetMemberRequest>
  Model::GetMemberOutcomeCallable GetMemberCallable(const GetMemberRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetMember, request);
  }
 
  template <typename GetMemberRequestT = Model::GetMemberRequest>
  void GetMemberAsync(const GetMemberRequestT& request, const GetMemberResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetMember, request, handler, context);
  }
 
  virtual Model::GetSbomExportOutcome GetSbomExport(const Model::GetSbomExportRequest& request) const;
 
  template <typename GetSbomExportRequestT = Model::GetSbomExportRequest>
  Model::GetSbomExportOutcomeCallable GetSbomExportCallable(const GetSbomExportRequestT& request) const {
    return SubmitCallable(&Inspector2Client::GetSbomExport, request);
  }
 
  template <typename GetSbomExportRequestT = Model::GetSbomExportRequest>
  void GetSbomExportAsync(const GetSbomExportRequestT& request, const GetSbomExportResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::GetSbomExport, request, handler, context);
  }
 
  virtual Model::ListAccountPermissionsOutcome ListAccountPermissions(const Model::ListAccountPermissionsRequest& request = {}) const;
 
  template <typename ListAccountPermissionsRequestT = Model::ListAccountPermissionsRequest>
  Model::ListAccountPermissionsOutcomeCallable ListAccountPermissionsCallable(const ListAccountPermissionsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListAccountPermissions, request);
  }
 
  template <typename ListAccountPermissionsRequestT = Model::ListAccountPermissionsRequest>
  void ListAccountPermissionsAsync(const ListAccountPermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListAccountPermissionsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListAccountPermissions, request, handler, context);
  }
 
  virtual Model::ListCisScanConfigurationsOutcome ListCisScanConfigurations(
      const Model::ListCisScanConfigurationsRequest& request = {}) const;
 
  template <typename ListCisScanConfigurationsRequestT = Model::ListCisScanConfigurationsRequest>
  Model::ListCisScanConfigurationsOutcomeCallable ListCisScanConfigurationsCallable(
      const ListCisScanConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListCisScanConfigurations, request);
  }
 
  template <typename ListCisScanConfigurationsRequestT = Model::ListCisScanConfigurationsRequest>
  void ListCisScanConfigurationsAsync(const ListCisScanConfigurationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListCisScanConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListCisScanConfigurations, request, handler, context);
  }
 
  virtual Model::ListCisScanResultsAggregatedByChecksOutcome ListCisScanResultsAggregatedByChecks(
      const Model::ListCisScanResultsAggregatedByChecksRequest& request) const;
 
  template <typename ListCisScanResultsAggregatedByChecksRequestT = Model::ListCisScanResultsAggregatedByChecksRequest>
  Model::ListCisScanResultsAggregatedByChecksOutcomeCallable ListCisScanResultsAggregatedByChecksCallable(
      const ListCisScanResultsAggregatedByChecksRequestT& request) const {
    return SubmitCallable(&Inspector2Client::ListCisScanResultsAggregatedByChecks, request);
  }
 
  template <typename ListCisScanResultsAggregatedByChecksRequestT = Model::ListCisScanResultsAggregatedByChecksRequest>
  void ListCisScanResultsAggregatedByChecksAsync(const ListCisScanResultsAggregatedByChecksRequestT& request,
                                                 const ListCisScanResultsAggregatedByChecksResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::ListCisScanResultsAggregatedByChecks, request, handler, context);
  }
 
  virtual Model::ListCisScanResultsAggregatedByTargetResourceOutcome ListCisScanResultsAggregatedByTargetResource(
      const Model::ListCisScanResultsAggregatedByTargetResourceRequest& request) const;
 
  template <typename ListCisScanResultsAggregatedByTargetResourceRequestT = Model::ListCisScanResultsAggregatedByTargetResourceRequest>
  Model::ListCisScanResultsAggregatedByTargetResourceOutcomeCallable ListCisScanResultsAggregatedByTargetResourceCallable(
      const ListCisScanResultsAggregatedByTargetResourceRequestT& request) const {
    return SubmitCallable(&Inspector2Client::ListCisScanResultsAggregatedByTargetResource, request);
  }
 
  template <typename ListCisScanResultsAggregatedByTargetResourceRequestT = Model::ListCisScanResultsAggregatedByTargetResourceRequest>
  void ListCisScanResultsAggregatedByTargetResourceAsync(
      const ListCisScanResultsAggregatedByTargetResourceRequestT& request,
      const ListCisScanResultsAggregatedByTargetResourceResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::ListCisScanResultsAggregatedByTargetResource, request, handler, context);
  }
 
  virtual Model::ListCisScansOutcome ListCisScans(const Model::ListCisScansRequest& request = {}) const;
 
  template <typename ListCisScansRequestT = Model::ListCisScansRequest>
  Model::ListCisScansOutcomeCallable ListCisScansCallable(const ListCisScansRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListCisScans, request);
  }
 
  template <typename ListCisScansRequestT = Model::ListCisScansRequest>
  void ListCisScansAsync(const ListCisScansResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListCisScansRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListCisScans, request, handler, context);
  }
 
  virtual Model::ListCodeSecurityIntegrationsOutcome ListCodeSecurityIntegrations(
      const Model::ListCodeSecurityIntegrationsRequest& request = {}) const;
 
  template <typename ListCodeSecurityIntegrationsRequestT = Model::ListCodeSecurityIntegrationsRequest>
  Model::ListCodeSecurityIntegrationsOutcomeCallable ListCodeSecurityIntegrationsCallable(
      const ListCodeSecurityIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListCodeSecurityIntegrations, request);
  }
 
  template <typename ListCodeSecurityIntegrationsRequestT = Model::ListCodeSecurityIntegrationsRequest>
  void ListCodeSecurityIntegrationsAsync(const ListCodeSecurityIntegrationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListCodeSecurityIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListCodeSecurityIntegrations, request, handler, context);
  }
 
  virtual Model::ListCodeSecurityScanConfigurationAssociationsOutcome ListCodeSecurityScanConfigurationAssociations(
      const Model::ListCodeSecurityScanConfigurationAssociationsRequest& request) const;
 
  template <typename ListCodeSecurityScanConfigurationAssociationsRequestT = Model::ListCodeSecurityScanConfigurationAssociationsRequest>
  Model::ListCodeSecurityScanConfigurationAssociationsOutcomeCallable ListCodeSecurityScanConfigurationAssociationsCallable(
      const ListCodeSecurityScanConfigurationAssociationsRequestT& request) const {
    return SubmitCallable(&Inspector2Client::ListCodeSecurityScanConfigurationAssociations, request);
  }
 
  template <typename ListCodeSecurityScanConfigurationAssociationsRequestT = Model::ListCodeSecurityScanConfigurationAssociationsRequest>
  void ListCodeSecurityScanConfigurationAssociationsAsync(
      const ListCodeSecurityScanConfigurationAssociationsRequestT& request,
      const ListCodeSecurityScanConfigurationAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::ListCodeSecurityScanConfigurationAssociations, request, handler, context);
  }
 
  virtual Model::ListCodeSecurityScanConfigurationsOutcome ListCodeSecurityScanConfigurations(
      const Model::ListCodeSecurityScanConfigurationsRequest& request = {}) const;
 
  template <typename ListCodeSecurityScanConfigurationsRequestT = Model::ListCodeSecurityScanConfigurationsRequest>
  Model::ListCodeSecurityScanConfigurationsOutcomeCallable ListCodeSecurityScanConfigurationsCallable(
      const ListCodeSecurityScanConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListCodeSecurityScanConfigurations, request);
  }
 
  template <typename ListCodeSecurityScanConfigurationsRequestT = Model::ListCodeSecurityScanConfigurationsRequest>
  void ListCodeSecurityScanConfigurationsAsync(const ListCodeSecurityScanConfigurationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const ListCodeSecurityScanConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListCodeSecurityScanConfigurations, request, handler, context);
  }
 
  virtual Model::ListConnectorScanConfigurationsOutcome ListConnectorScanConfigurations(
      const Model::ListConnectorScanConfigurationsRequest& request = {}) const;
 
  template <typename ListConnectorScanConfigurationsRequestT = Model::ListConnectorScanConfigurationsRequest>
  Model::ListConnectorScanConfigurationsOutcomeCallable ListConnectorScanConfigurationsCallable(
      const ListConnectorScanConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListConnectorScanConfigurations, request);
  }
 
  template <typename ListConnectorScanConfigurationsRequestT = Model::ListConnectorScanConfigurationsRequest>
  void ListConnectorScanConfigurationsAsync(const ListConnectorScanConfigurationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const ListConnectorScanConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListConnectorScanConfigurations, request, handler, context);
  }
 
  virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListConnectors, request);
  }
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListConnectorsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListConnectors, request, handler, context);
  }
 
  virtual Model::ListCoverageOutcome ListCoverage(const Model::ListCoverageRequest& request = {}) const;
 
  template <typename ListCoverageRequestT = Model::ListCoverageRequest>
  Model::ListCoverageOutcomeCallable ListCoverageCallable(const ListCoverageRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListCoverage, request);
  }
 
  template <typename ListCoverageRequestT = Model::ListCoverageRequest>
  void ListCoverageAsync(const ListCoverageResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListCoverageRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListCoverage, request, handler, context);
  }
 
  virtual Model::ListCoverageStatisticsOutcome ListCoverageStatistics(const Model::ListCoverageStatisticsRequest& request = {}) const;
 
  template <typename ListCoverageStatisticsRequestT = Model::ListCoverageStatisticsRequest>
  Model::ListCoverageStatisticsOutcomeCallable ListCoverageStatisticsCallable(const ListCoverageStatisticsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListCoverageStatistics, request);
  }
 
  template <typename ListCoverageStatisticsRequestT = Model::ListCoverageStatisticsRequest>
  void ListCoverageStatisticsAsync(const ListCoverageStatisticsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListCoverageStatisticsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListCoverageStatistics, request, handler, context);
  }
 
  virtual Model::ListDelegatedAdminAccountsOutcome ListDelegatedAdminAccounts(
      const Model::ListDelegatedAdminAccountsRequest& request = {}) const;
 
  template <typename ListDelegatedAdminAccountsRequestT = Model::ListDelegatedAdminAccountsRequest>
  Model::ListDelegatedAdminAccountsOutcomeCallable ListDelegatedAdminAccountsCallable(
      const ListDelegatedAdminAccountsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListDelegatedAdminAccounts, request);
  }
 
  template <typename ListDelegatedAdminAccountsRequestT = Model::ListDelegatedAdminAccountsRequest>
  void ListDelegatedAdminAccountsAsync(const ListDelegatedAdminAccountsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListDelegatedAdminAccountsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListDelegatedAdminAccounts, request, handler, context);
  }
 
  virtual Model::ListFiltersOutcome ListFilters(const Model::ListFiltersRequest& request = {}) const;
 
  template <typename ListFiltersRequestT = Model::ListFiltersRequest>
  Model::ListFiltersOutcomeCallable ListFiltersCallable(const ListFiltersRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListFilters, request);
  }
 
  template <typename ListFiltersRequestT = Model::ListFiltersRequest>
  void ListFiltersAsync(const ListFiltersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListFiltersRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListFilters, request, handler, context);
  }
 
  virtual Model::ListFindingAggregationsOutcome ListFindingAggregations(const Model::ListFindingAggregationsRequest& request) const;
 
  template <typename ListFindingAggregationsRequestT = Model::ListFindingAggregationsRequest>
  Model::ListFindingAggregationsOutcomeCallable ListFindingAggregationsCallable(const ListFindingAggregationsRequestT& request) const {
    return SubmitCallable(&Inspector2Client::ListFindingAggregations, request);
  }
 
  template <typename ListFindingAggregationsRequestT = Model::ListFindingAggregationsRequest>
  void ListFindingAggregationsAsync(const ListFindingAggregationsRequestT& request,
                                    const ListFindingAggregationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::ListFindingAggregations, request, handler, context);
  }
 
  virtual Model::ListFindingsOutcome ListFindings(const Model::ListFindingsRequest& request = {}) const;
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  Model::ListFindingsOutcomeCallable ListFindingsCallable(const ListFindingsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListFindings, request);
  }
 
  template <typename ListFindingsRequestT = Model::ListFindingsRequest>
  void ListFindingsAsync(const ListFindingsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListFindingsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListFindings, request, handler, context);
  }
 
  virtual Model::ListMembersOutcome ListMembers(const Model::ListMembersRequest& request = {}) const;
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  Model::ListMembersOutcomeCallable ListMembersCallable(const ListMembersRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListMembers, request);
  }
 
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  void ListMembersAsync(const ListMembersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListMembersRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListMembers, 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(&Inspector2Client::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(&Inspector2Client::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListUsageTotalsOutcome ListUsageTotals(const Model::ListUsageTotalsRequest& request = {}) const;
 
  template <typename ListUsageTotalsRequestT = Model::ListUsageTotalsRequest>
  Model::ListUsageTotalsOutcomeCallable ListUsageTotalsCallable(const ListUsageTotalsRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::ListUsageTotals, request);
  }
 
  template <typename ListUsageTotalsRequestT = Model::ListUsageTotalsRequest>
  void ListUsageTotalsAsync(const ListUsageTotalsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListUsageTotalsRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::ListUsageTotals, request, handler, context);
  }
 
  virtual Model::ResetEncryptionKeyOutcome ResetEncryptionKey(const Model::ResetEncryptionKeyRequest& request) const;
 
  template <typename ResetEncryptionKeyRequestT = Model::ResetEncryptionKeyRequest>
  Model::ResetEncryptionKeyOutcomeCallable ResetEncryptionKeyCallable(const ResetEncryptionKeyRequestT& request) const {
    return SubmitCallable(&Inspector2Client::ResetEncryptionKey, request);
  }
 
  template <typename ResetEncryptionKeyRequestT = Model::ResetEncryptionKeyRequest>
  void ResetEncryptionKeyAsync(const ResetEncryptionKeyRequestT& request, const ResetEncryptionKeyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::ResetEncryptionKey, request, handler, context);
  }
 
  virtual Model::SearchVulnerabilitiesOutcome SearchVulnerabilities(const Model::SearchVulnerabilitiesRequest& request) const;
 
  template <typename SearchVulnerabilitiesRequestT = Model::SearchVulnerabilitiesRequest>
  Model::SearchVulnerabilitiesOutcomeCallable SearchVulnerabilitiesCallable(const SearchVulnerabilitiesRequestT& request) const {
    return SubmitCallable(&Inspector2Client::SearchVulnerabilities, request);
  }
 
  template <typename SearchVulnerabilitiesRequestT = Model::SearchVulnerabilitiesRequest>
  void SearchVulnerabilitiesAsync(const SearchVulnerabilitiesRequestT& request, const SearchVulnerabilitiesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::SearchVulnerabilities, request, handler, context);
  }
 
  virtual Model::SendCisSessionHealthOutcome SendCisSessionHealth(const Model::SendCisSessionHealthRequest& request) const;
 
  template <typename SendCisSessionHealthRequestT = Model::SendCisSessionHealthRequest>
  Model::SendCisSessionHealthOutcomeCallable SendCisSessionHealthCallable(const SendCisSessionHealthRequestT& request) const {
    return SubmitCallable(&Inspector2Client::SendCisSessionHealth, request);
  }
 
  template <typename SendCisSessionHealthRequestT = Model::SendCisSessionHealthRequest>
  void SendCisSessionHealthAsync(const SendCisSessionHealthRequestT& request, const SendCisSessionHealthResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::SendCisSessionHealth, request, handler, context);
  }
 
  virtual Model::SendCisSessionTelemetryOutcome SendCisSessionTelemetry(const Model::SendCisSessionTelemetryRequest& request) const;
 
  template <typename SendCisSessionTelemetryRequestT = Model::SendCisSessionTelemetryRequest>
  Model::SendCisSessionTelemetryOutcomeCallable SendCisSessionTelemetryCallable(const SendCisSessionTelemetryRequestT& request) const {
    return SubmitCallable(&Inspector2Client::SendCisSessionTelemetry, request);
  }
 
  template <typename SendCisSessionTelemetryRequestT = Model::SendCisSessionTelemetryRequest>
  void SendCisSessionTelemetryAsync(const SendCisSessionTelemetryRequestT& request,
                                    const SendCisSessionTelemetryResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::SendCisSessionTelemetry, request, handler, context);
  }
 
  virtual Model::StartCisSessionOutcome StartCisSession(const Model::StartCisSessionRequest& request) const;
 
  template <typename StartCisSessionRequestT = Model::StartCisSessionRequest>
  Model::StartCisSessionOutcomeCallable StartCisSessionCallable(const StartCisSessionRequestT& request) const {
    return SubmitCallable(&Inspector2Client::StartCisSession, request);
  }
 
  template <typename StartCisSessionRequestT = Model::StartCisSessionRequest>
  void StartCisSessionAsync(const StartCisSessionRequestT& request, const StartCisSessionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::StartCisSession, request, handler, context);
  }
 
  virtual Model::StartCodeSecurityScanOutcome StartCodeSecurityScan(const Model::StartCodeSecurityScanRequest& request) const;
 
  template <typename StartCodeSecurityScanRequestT = Model::StartCodeSecurityScanRequest>
  Model::StartCodeSecurityScanOutcomeCallable StartCodeSecurityScanCallable(const StartCodeSecurityScanRequestT& request) const {
    return SubmitCallable(&Inspector2Client::StartCodeSecurityScan, request);
  }
 
  template <typename StartCodeSecurityScanRequestT = Model::StartCodeSecurityScanRequest>
  void StartCodeSecurityScanAsync(const StartCodeSecurityScanRequestT& request, const StartCodeSecurityScanResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::StartCodeSecurityScan, request, handler, context);
  }
 
  virtual Model::StopCisSessionOutcome StopCisSession(const Model::StopCisSessionRequest& request) const;
 
  template <typename StopCisSessionRequestT = Model::StopCisSessionRequest>
  Model::StopCisSessionOutcomeCallable StopCisSessionCallable(const StopCisSessionRequestT& request) const {
    return SubmitCallable(&Inspector2Client::StopCisSession, request);
  }
 
  template <typename StopCisSessionRequestT = Model::StopCisSessionRequest>
  void StopCisSessionAsync(const StopCisSessionRequestT& request, const StopCisSessionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::StopCisSession, 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(&Inspector2Client::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(&Inspector2Client::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(&Inspector2Client::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(&Inspector2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCisScanConfigurationOutcome UpdateCisScanConfiguration(
      const Model::UpdateCisScanConfigurationRequest& request) const;
 
  template <typename UpdateCisScanConfigurationRequestT = Model::UpdateCisScanConfigurationRequest>
  Model::UpdateCisScanConfigurationOutcomeCallable UpdateCisScanConfigurationCallable(
      const UpdateCisScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateCisScanConfiguration, request);
  }
 
  template <typename UpdateCisScanConfigurationRequestT = Model::UpdateCisScanConfigurationRequest>
  void UpdateCisScanConfigurationAsync(const UpdateCisScanConfigurationRequestT& request,
                                       const UpdateCisScanConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateCisScanConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateCodeSecurityIntegrationOutcome UpdateCodeSecurityIntegration(
      const Model::UpdateCodeSecurityIntegrationRequest& request) const;
 
  template <typename UpdateCodeSecurityIntegrationRequestT = Model::UpdateCodeSecurityIntegrationRequest>
  Model::UpdateCodeSecurityIntegrationOutcomeCallable UpdateCodeSecurityIntegrationCallable(
      const UpdateCodeSecurityIntegrationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateCodeSecurityIntegration, request);
  }
 
  template <typename UpdateCodeSecurityIntegrationRequestT = Model::UpdateCodeSecurityIntegrationRequest>
  void UpdateCodeSecurityIntegrationAsync(const UpdateCodeSecurityIntegrationRequestT& request,
                                          const UpdateCodeSecurityIntegrationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateCodeSecurityIntegration, request, handler, context);
  }
 
  virtual Model::UpdateCodeSecurityScanConfigurationOutcome UpdateCodeSecurityScanConfiguration(
      const Model::UpdateCodeSecurityScanConfigurationRequest& request) const;
 
  template <typename UpdateCodeSecurityScanConfigurationRequestT = Model::UpdateCodeSecurityScanConfigurationRequest>
  Model::UpdateCodeSecurityScanConfigurationOutcomeCallable UpdateCodeSecurityScanConfigurationCallable(
      const UpdateCodeSecurityScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateCodeSecurityScanConfiguration, request);
  }
 
  template <typename UpdateCodeSecurityScanConfigurationRequestT = Model::UpdateCodeSecurityScanConfigurationRequest>
  void UpdateCodeSecurityScanConfigurationAsync(const UpdateCodeSecurityScanConfigurationRequestT& request,
                                                const UpdateCodeSecurityScanConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateCodeSecurityScanConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateConfigurationOutcome UpdateConfiguration(const Model::UpdateConfigurationRequest& request = {}) const;
 
  template <typename UpdateConfigurationRequestT = Model::UpdateConfigurationRequest>
  Model::UpdateConfigurationOutcomeCallable UpdateConfigurationCallable(const UpdateConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::UpdateConfiguration, request);
  }
 
  template <typename UpdateConfigurationRequestT = Model::UpdateConfigurationRequest>
  void UpdateConfigurationAsync(const UpdateConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const UpdateConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::UpdateConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateConnectorOutcome UpdateConnector(const Model::UpdateConnectorRequest& request) const;
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  Model::UpdateConnectorOutcomeCallable UpdateConnectorCallable(const UpdateConnectorRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateConnector, request);
  }
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  void UpdateConnectorAsync(const UpdateConnectorRequestT& request, const UpdateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateConnector, request, handler, context);
  }
 
  virtual Model::UpdateConnectorScanConfigurationOutcome UpdateConnectorScanConfiguration(
      const Model::UpdateConnectorScanConfigurationRequest& request) const;
 
  template <typename UpdateConnectorScanConfigurationRequestT = Model::UpdateConnectorScanConfigurationRequest>
  Model::UpdateConnectorScanConfigurationOutcomeCallable UpdateConnectorScanConfigurationCallable(
      const UpdateConnectorScanConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateConnectorScanConfiguration, request);
  }
 
  template <typename UpdateConnectorScanConfigurationRequestT = Model::UpdateConnectorScanConfigurationRequest>
  void UpdateConnectorScanConfigurationAsync(const UpdateConnectorScanConfigurationRequestT& request,
                                             const UpdateConnectorScanConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateConnectorScanConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateEc2DeepInspectionConfigurationOutcome UpdateEc2DeepInspectionConfiguration(
      const Model::UpdateEc2DeepInspectionConfigurationRequest& request = {}) const;
 
  template <typename UpdateEc2DeepInspectionConfigurationRequestT = Model::UpdateEc2DeepInspectionConfigurationRequest>
  Model::UpdateEc2DeepInspectionConfigurationOutcomeCallable UpdateEc2DeepInspectionConfigurationCallable(
      const UpdateEc2DeepInspectionConfigurationRequestT& request = {}) const {
    return SubmitCallable(&Inspector2Client::UpdateEc2DeepInspectionConfiguration, request);
  }
 
  template <typename UpdateEc2DeepInspectionConfigurationRequestT = Model::UpdateEc2DeepInspectionConfigurationRequest>
  void UpdateEc2DeepInspectionConfigurationAsync(const UpdateEc2DeepInspectionConfigurationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const UpdateEc2DeepInspectionConfigurationRequestT& request = {}) const {
    return SubmitAsync(&Inspector2Client::UpdateEc2DeepInspectionConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateEncryptionKeyOutcome UpdateEncryptionKey(const Model::UpdateEncryptionKeyRequest& request) const;
 
  template <typename UpdateEncryptionKeyRequestT = Model::UpdateEncryptionKeyRequest>
  Model::UpdateEncryptionKeyOutcomeCallable UpdateEncryptionKeyCallable(const UpdateEncryptionKeyRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateEncryptionKey, request);
  }
 
  template <typename UpdateEncryptionKeyRequestT = Model::UpdateEncryptionKeyRequest>
  void UpdateEncryptionKeyAsync(const UpdateEncryptionKeyRequestT& request, const UpdateEncryptionKeyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateEncryptionKey, request, handler, context);
  }
 
  virtual Model::UpdateFilterOutcome UpdateFilter(const Model::UpdateFilterRequest& request) const;
 
  template <typename UpdateFilterRequestT = Model::UpdateFilterRequest>
  Model::UpdateFilterOutcomeCallable UpdateFilterCallable(const UpdateFilterRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateFilter, request);
  }
 
  template <typename UpdateFilterRequestT = Model::UpdateFilterRequest>
  void UpdateFilterAsync(const UpdateFilterRequestT& request, const UpdateFilterResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateFilter, request, handler, context);
  }
 
  virtual Model::UpdateOrgEc2DeepInspectionConfigurationOutcome UpdateOrgEc2DeepInspectionConfiguration(
      const Model::UpdateOrgEc2DeepInspectionConfigurationRequest& request) const;
 
  template <typename UpdateOrgEc2DeepInspectionConfigurationRequestT = Model::UpdateOrgEc2DeepInspectionConfigurationRequest>
  Model::UpdateOrgEc2DeepInspectionConfigurationOutcomeCallable UpdateOrgEc2DeepInspectionConfigurationCallable(
      const UpdateOrgEc2DeepInspectionConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateOrgEc2DeepInspectionConfiguration, request);
  }
 
  template <typename UpdateOrgEc2DeepInspectionConfigurationRequestT = Model::UpdateOrgEc2DeepInspectionConfigurationRequest>
  void UpdateOrgEc2DeepInspectionConfigurationAsync(const UpdateOrgEc2DeepInspectionConfigurationRequestT& request,
                                                    const UpdateOrgEc2DeepInspectionConfigurationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateOrgEc2DeepInspectionConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateOrganizationConfigurationOutcome UpdateOrganizationConfiguration(
      const Model::UpdateOrganizationConfigurationRequest& request) const;
 
  template <typename UpdateOrganizationConfigurationRequestT = Model::UpdateOrganizationConfigurationRequest>
  Model::UpdateOrganizationConfigurationOutcomeCallable UpdateOrganizationConfigurationCallable(
      const UpdateOrganizationConfigurationRequestT& request) const {
    return SubmitCallable(&Inspector2Client::UpdateOrganizationConfiguration, request);
  }
 
  template <typename UpdateOrganizationConfigurationRequestT = Model::UpdateOrganizationConfigurationRequest>
  void UpdateOrganizationConfigurationAsync(const UpdateOrganizationConfigurationRequestT& request,
                                            const UpdateOrganizationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Inspector2Client::UpdateOrganizationConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Inspector2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Inspector2Client>;
  void init(const Inspector2ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Inspector2Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  Inspector2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<Inspector2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Inspector2
}  // namespace Aws