DetectiveClient.h

 
#pragma once
#include <aws/detective/Detective_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/detective/DetectiveServiceClientModel.h>
 
namespace Aws
{
namespace Detective
{
  class AWS_DETECTIVE_API DetectiveClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DetectiveClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DetectiveClientConfiguration ClientConfigurationType;
      typedef DetectiveEndpointProvider EndpointProviderType;
 
        DetectiveClient(const Aws::Detective::DetectiveClientConfiguration& clientConfiguration = Aws::Detective::DetectiveClientConfiguration(),
                        std::shared_ptr<DetectiveEndpointProviderBase> endpointProvider = nullptr);
 
        DetectiveClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<DetectiveEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::Detective::DetectiveClientConfiguration& clientConfiguration = Aws::Detective::DetectiveClientConfiguration());
 
        DetectiveClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<DetectiveEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::Detective::DetectiveClientConfiguration& clientConfiguration = Aws::Detective::DetectiveClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DetectiveClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DetectiveClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DetectiveClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DetectiveClient();
 
        virtual Model::AcceptInvitationOutcome AcceptInvitation(const Model::AcceptInvitationRequest& request) const;
 
        template<typename AcceptInvitationRequestT = Model::AcceptInvitationRequest>
        Model::AcceptInvitationOutcomeCallable AcceptInvitationCallable(const AcceptInvitationRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::AcceptInvitation, request);
        }
 
        template<typename AcceptInvitationRequestT = Model::AcceptInvitationRequest>
        void AcceptInvitationAsync(const AcceptInvitationRequestT& request, const AcceptInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::AcceptInvitation, request, handler, context);
        }
 
        virtual Model::BatchGetGraphMemberDatasourcesOutcome BatchGetGraphMemberDatasources(const Model::BatchGetGraphMemberDatasourcesRequest& request) const;
 
        template<typename BatchGetGraphMemberDatasourcesRequestT = Model::BatchGetGraphMemberDatasourcesRequest>
        Model::BatchGetGraphMemberDatasourcesOutcomeCallable BatchGetGraphMemberDatasourcesCallable(const BatchGetGraphMemberDatasourcesRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::BatchGetGraphMemberDatasources, request);
        }
 
        template<typename BatchGetGraphMemberDatasourcesRequestT = Model::BatchGetGraphMemberDatasourcesRequest>
        void BatchGetGraphMemberDatasourcesAsync(const BatchGetGraphMemberDatasourcesRequestT& request, const BatchGetGraphMemberDatasourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::BatchGetGraphMemberDatasources, request, handler, context);
        }
 
        virtual Model::BatchGetMembershipDatasourcesOutcome BatchGetMembershipDatasources(const Model::BatchGetMembershipDatasourcesRequest& request) const;
 
        template<typename BatchGetMembershipDatasourcesRequestT = Model::BatchGetMembershipDatasourcesRequest>
        Model::BatchGetMembershipDatasourcesOutcomeCallable BatchGetMembershipDatasourcesCallable(const BatchGetMembershipDatasourcesRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::BatchGetMembershipDatasources, request);
        }
 
        template<typename BatchGetMembershipDatasourcesRequestT = Model::BatchGetMembershipDatasourcesRequest>
        void BatchGetMembershipDatasourcesAsync(const BatchGetMembershipDatasourcesRequestT& request, const BatchGetMembershipDatasourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::BatchGetMembershipDatasources, request, handler, context);
        }
 
        virtual Model::CreateGraphOutcome CreateGraph(const Model::CreateGraphRequest& request = {}) const;
 
        template<typename CreateGraphRequestT = Model::CreateGraphRequest>
        Model::CreateGraphOutcomeCallable CreateGraphCallable(const CreateGraphRequestT& request = {}) const
        {
            return SubmitCallable(&DetectiveClient::CreateGraph, request);
        }
 
        template<typename CreateGraphRequestT = Model::CreateGraphRequest>
        void CreateGraphAsync(const CreateGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateGraphRequestT& request = {}) const
        {
            return SubmitAsync(&DetectiveClient::CreateGraph, request, handler, context);
        }
 
        virtual Model::CreateMembersOutcome CreateMembers(const Model::CreateMembersRequest& request) const;
 
        template<typename CreateMembersRequestT = Model::CreateMembersRequest>
        Model::CreateMembersOutcomeCallable CreateMembersCallable(const CreateMembersRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::CreateMembers, request);
        }
 
        template<typename CreateMembersRequestT = Model::CreateMembersRequest>
        void CreateMembersAsync(const CreateMembersRequestT& request, const CreateMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::CreateMembers, request, handler, context);
        }
 
        virtual Model::DeleteGraphOutcome DeleteGraph(const Model::DeleteGraphRequest& request) const;
 
        template<typename DeleteGraphRequestT = Model::DeleteGraphRequest>
        Model::DeleteGraphOutcomeCallable DeleteGraphCallable(const DeleteGraphRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::DeleteGraph, request);
        }
 
        template<typename DeleteGraphRequestT = Model::DeleteGraphRequest>
        void DeleteGraphAsync(const DeleteGraphRequestT& request, const DeleteGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::DeleteGraph, request, handler, context);
        }
 
        virtual Model::DeleteMembersOutcome DeleteMembers(const Model::DeleteMembersRequest& request) const;
 
        template<typename DeleteMembersRequestT = Model::DeleteMembersRequest>
        Model::DeleteMembersOutcomeCallable DeleteMembersCallable(const DeleteMembersRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::DeleteMembers, request);
        }
 
        template<typename DeleteMembersRequestT = Model::DeleteMembersRequest>
        void DeleteMembersAsync(const DeleteMembersRequestT& request, const DeleteMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::DeleteMembers, 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(&DetectiveClient::DescribeOrganizationConfiguration, request);
        }
 
        template<typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
        void DescribeOrganizationConfigurationAsync(const DescribeOrganizationConfigurationRequestT& request, const DescribeOrganizationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::DescribeOrganizationConfiguration, request, handler, context);
        }
 
        virtual Model::DisableOrganizationAdminAccountOutcome DisableOrganizationAdminAccount(const Model::DisableOrganizationAdminAccountRequest& request = {}) const;
 
        template<typename DisableOrganizationAdminAccountRequestT = Model::DisableOrganizationAdminAccountRequest>
        Model::DisableOrganizationAdminAccountOutcomeCallable DisableOrganizationAdminAccountCallable(const DisableOrganizationAdminAccountRequestT& request = {}) const
        {
            return SubmitCallable(&DetectiveClient::DisableOrganizationAdminAccount, request);
        }
 
        template<typename DisableOrganizationAdminAccountRequestT = Model::DisableOrganizationAdminAccountRequest>
        void DisableOrganizationAdminAccountAsync(const DisableOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisableOrganizationAdminAccountRequestT& request = {}) const
        {
            return SubmitAsync(&DetectiveClient::DisableOrganizationAdminAccount, request, handler, context);
        }
 
        virtual Model::DisassociateMembershipOutcome DisassociateMembership(const Model::DisassociateMembershipRequest& request) const;
 
        template<typename DisassociateMembershipRequestT = Model::DisassociateMembershipRequest>
        Model::DisassociateMembershipOutcomeCallable DisassociateMembershipCallable(const DisassociateMembershipRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::DisassociateMembership, request);
        }
 
        template<typename DisassociateMembershipRequestT = Model::DisassociateMembershipRequest>
        void DisassociateMembershipAsync(const DisassociateMembershipRequestT& request, const DisassociateMembershipResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::DisassociateMembership, request, handler, context);
        }
 
        virtual Model::EnableOrganizationAdminAccountOutcome EnableOrganizationAdminAccount(const Model::EnableOrganizationAdminAccountRequest& request) const;
 
        template<typename EnableOrganizationAdminAccountRequestT = Model::EnableOrganizationAdminAccountRequest>
        Model::EnableOrganizationAdminAccountOutcomeCallable EnableOrganizationAdminAccountCallable(const EnableOrganizationAdminAccountRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::EnableOrganizationAdminAccount, request);
        }
 
        template<typename EnableOrganizationAdminAccountRequestT = Model::EnableOrganizationAdminAccountRequest>
        void EnableOrganizationAdminAccountAsync(const EnableOrganizationAdminAccountRequestT& request, const EnableOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::EnableOrganizationAdminAccount, request, handler, context);
        }
 
        virtual Model::GetInvestigationOutcome GetInvestigation(const Model::GetInvestigationRequest& request) const;
 
        template<typename GetInvestigationRequestT = Model::GetInvestigationRequest>
        Model::GetInvestigationOutcomeCallable GetInvestigationCallable(const GetInvestigationRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::GetInvestigation, request);
        }
 
        template<typename GetInvestigationRequestT = Model::GetInvestigationRequest>
        void GetInvestigationAsync(const GetInvestigationRequestT& request, const GetInvestigationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::GetInvestigation, request, handler, context);
        }
 
        virtual Model::GetMembersOutcome GetMembers(const Model::GetMembersRequest& request) const;
 
        template<typename GetMembersRequestT = Model::GetMembersRequest>
        Model::GetMembersOutcomeCallable GetMembersCallable(const GetMembersRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::GetMembers, request);
        }
 
        template<typename GetMembersRequestT = Model::GetMembersRequest>
        void GetMembersAsync(const GetMembersRequestT& request, const GetMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::GetMembers, request, handler, context);
        }
 
        virtual Model::ListDatasourcePackagesOutcome ListDatasourcePackages(const Model::ListDatasourcePackagesRequest& request) const;
 
        template<typename ListDatasourcePackagesRequestT = Model::ListDatasourcePackagesRequest>
        Model::ListDatasourcePackagesOutcomeCallable ListDatasourcePackagesCallable(const ListDatasourcePackagesRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::ListDatasourcePackages, request);
        }
 
        template<typename ListDatasourcePackagesRequestT = Model::ListDatasourcePackagesRequest>
        void ListDatasourcePackagesAsync(const ListDatasourcePackagesRequestT& request, const ListDatasourcePackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::ListDatasourcePackages, request, handler, context);
        }
 
        virtual Model::ListGraphsOutcome ListGraphs(const Model::ListGraphsRequest& request = {}) const;
 
        template<typename ListGraphsRequestT = Model::ListGraphsRequest>
        Model::ListGraphsOutcomeCallable ListGraphsCallable(const ListGraphsRequestT& request = {}) const
        {
            return SubmitCallable(&DetectiveClient::ListGraphs, request);
        }
 
        template<typename ListGraphsRequestT = Model::ListGraphsRequest>
        void ListGraphsAsync(const ListGraphsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGraphsRequestT& request = {}) const
        {
            return SubmitAsync(&DetectiveClient::ListGraphs, request, handler, context);
        }
 
        virtual Model::ListIndicatorsOutcome ListIndicators(const Model::ListIndicatorsRequest& request) const;
 
        template<typename ListIndicatorsRequestT = Model::ListIndicatorsRequest>
        Model::ListIndicatorsOutcomeCallable ListIndicatorsCallable(const ListIndicatorsRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::ListIndicators, request);
        }
 
        template<typename ListIndicatorsRequestT = Model::ListIndicatorsRequest>
        void ListIndicatorsAsync(const ListIndicatorsRequestT& request, const ListIndicatorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::ListIndicators, request, handler, context);
        }
 
        virtual Model::ListInvestigationsOutcome ListInvestigations(const Model::ListInvestigationsRequest& request) const;
 
        template<typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
        Model::ListInvestigationsOutcomeCallable ListInvestigationsCallable(const ListInvestigationsRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::ListInvestigations, request);
        }
 
        template<typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
        void ListInvestigationsAsync(const ListInvestigationsRequestT& request, const ListInvestigationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::ListInvestigations, request, handler, context);
        }
 
        virtual Model::ListInvitationsOutcome ListInvitations(const Model::ListInvitationsRequest& request = {}) const;
 
        template<typename ListInvitationsRequestT = Model::ListInvitationsRequest>
        Model::ListInvitationsOutcomeCallable ListInvitationsCallable(const ListInvitationsRequestT& request = {}) const
        {
            return SubmitCallable(&DetectiveClient::ListInvitations, request);
        }
 
        template<typename ListInvitationsRequestT = Model::ListInvitationsRequest>
        void ListInvitationsAsync(const ListInvitationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInvitationsRequestT& request = {}) const
        {
            return SubmitAsync(&DetectiveClient::ListInvitations, 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(&DetectiveClient::ListMembers, request);
        }
 
        template<typename ListMembersRequestT = Model::ListMembersRequest>
        void ListMembersAsync(const ListMembersRequestT& request, const ListMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::ListMembers, request, handler, context);
        }
 
        virtual Model::ListOrganizationAdminAccountsOutcome ListOrganizationAdminAccounts(const Model::ListOrganizationAdminAccountsRequest& request = {}) const;
 
        template<typename ListOrganizationAdminAccountsRequestT = Model::ListOrganizationAdminAccountsRequest>
        Model::ListOrganizationAdminAccountsOutcomeCallable ListOrganizationAdminAccountsCallable(const ListOrganizationAdminAccountsRequestT& request = {}) const
        {
            return SubmitCallable(&DetectiveClient::ListOrganizationAdminAccounts, request);
        }
 
        template<typename ListOrganizationAdminAccountsRequestT = Model::ListOrganizationAdminAccountsRequest>
        void ListOrganizationAdminAccountsAsync(const ListOrganizationAdminAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOrganizationAdminAccountsRequestT& request = {}) const
        {
            return SubmitAsync(&DetectiveClient::ListOrganizationAdminAccounts, 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(&DetectiveClient::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(&DetectiveClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RejectInvitationOutcome RejectInvitation(const Model::RejectInvitationRequest& request) const;
 
        template<typename RejectInvitationRequestT = Model::RejectInvitationRequest>
        Model::RejectInvitationOutcomeCallable RejectInvitationCallable(const RejectInvitationRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::RejectInvitation, request);
        }
 
        template<typename RejectInvitationRequestT = Model::RejectInvitationRequest>
        void RejectInvitationAsync(const RejectInvitationRequestT& request, const RejectInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::RejectInvitation, request, handler, context);
        }
 
        virtual Model::StartInvestigationOutcome StartInvestigation(const Model::StartInvestigationRequest& request) const;
 
        template<typename StartInvestigationRequestT = Model::StartInvestigationRequest>
        Model::StartInvestigationOutcomeCallable StartInvestigationCallable(const StartInvestigationRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::StartInvestigation, request);
        }
 
        template<typename StartInvestigationRequestT = Model::StartInvestigationRequest>
        void StartInvestigationAsync(const StartInvestigationRequestT& request, const StartInvestigationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::StartInvestigation, request, handler, context);
        }
 
        virtual Model::StartMonitoringMemberOutcome StartMonitoringMember(const Model::StartMonitoringMemberRequest& request) const;
 
        template<typename StartMonitoringMemberRequestT = Model::StartMonitoringMemberRequest>
        Model::StartMonitoringMemberOutcomeCallable StartMonitoringMemberCallable(const StartMonitoringMemberRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::StartMonitoringMember, request);
        }
 
        template<typename StartMonitoringMemberRequestT = Model::StartMonitoringMemberRequest>
        void StartMonitoringMemberAsync(const StartMonitoringMemberRequestT& request, const StartMonitoringMemberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::StartMonitoringMember, 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(&DetectiveClient::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(&DetectiveClient::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(&DetectiveClient::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(&DetectiveClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDatasourcePackagesOutcome UpdateDatasourcePackages(const Model::UpdateDatasourcePackagesRequest& request) const;
 
        template<typename UpdateDatasourcePackagesRequestT = Model::UpdateDatasourcePackagesRequest>
        Model::UpdateDatasourcePackagesOutcomeCallable UpdateDatasourcePackagesCallable(const UpdateDatasourcePackagesRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::UpdateDatasourcePackages, request);
        }
 
        template<typename UpdateDatasourcePackagesRequestT = Model::UpdateDatasourcePackagesRequest>
        void UpdateDatasourcePackagesAsync(const UpdateDatasourcePackagesRequestT& request, const UpdateDatasourcePackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::UpdateDatasourcePackages, request, handler, context);
        }
 
        virtual Model::UpdateInvestigationStateOutcome UpdateInvestigationState(const Model::UpdateInvestigationStateRequest& request) const;
 
        template<typename UpdateInvestigationStateRequestT = Model::UpdateInvestigationStateRequest>
        Model::UpdateInvestigationStateOutcomeCallable UpdateInvestigationStateCallable(const UpdateInvestigationStateRequestT& request) const
        {
            return SubmitCallable(&DetectiveClient::UpdateInvestigationState, request);
        }
 
        template<typename UpdateInvestigationStateRequestT = Model::UpdateInvestigationStateRequest>
        void UpdateInvestigationStateAsync(const UpdateInvestigationStateRequestT& request, const UpdateInvestigationStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DetectiveClient::UpdateInvestigationState, 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(&DetectiveClient::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(&DetectiveClient::UpdateOrganizationConfiguration, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DetectiveEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DetectiveClient>;
      void init(const DetectiveClientConfiguration& clientConfiguration);
 
      DetectiveClientConfiguration m_clientConfiguration;
      std::shared_ptr<DetectiveEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Detective
} // namespace Aws