Inspector2Client.h

 
#pragma once
#include <aws/inspector2/Inspector2_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/inspector2/Inspector2ServiceClientModel.h>
 
namespace Aws
{
namespace Inspector2
{
  class AWS_INSPECTOR2_API Inspector2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<Inspector2EndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<Inspector2Client>;
      void init(const Inspector2ClientConfiguration& clientConfiguration);
 
      Inspector2ClientConfiguration m_clientConfiguration;
      std::shared_ptr<Inspector2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Inspector2
} // namespace Aws