DetectiveClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/detective/DetectivePaginationBase.h>
#include <aws/detective/DetectiveServiceClientModel.h>
#include <aws/detective/Detective_EXPORTS.h>
 
namespace Aws {
namespace Detective {
class AWS_DETECTIVE_API DetectiveClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<DetectiveClient>,
                                          public DetectivePaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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