/**
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */

#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/DetectiveServiceClientModel.h>
#include <aws/detective/Detective_EXPORTS.h>

namespace Aws {
namespace Detective {
/**
 * <p>Detective uses machine learning and purpose-built visualizations to help you
 * to analyze and investigate security issues across your Amazon Web Services
 * (Amazon Web Services) workloads. Detective automatically extracts time-based
 * events such as login attempts, API calls, and network traffic from CloudTrail
 * and Amazon Virtual Private Cloud (Amazon VPC) flow logs. It also extracts
 * findings detected by Amazon GuardDuty.</p> <p>The Detective API primarily
 * supports the creation and management of behavior graphs. A behavior graph
 * contains the extracted data from a set of member accounts, and is created and
 * managed by an administrator account.</p> <p>To add a member account to the
 * behavior graph, the administrator account sends an invitation to the account.
 * When the account accepts the invitation, it becomes a member account in the
 * behavior graph.</p> <p>Detective is also integrated with Organizations. The
 * organization management account designates the Detective administrator account
 * for the organization. That account becomes the administrator account for the
 * organization behavior graph. The Detective administrator account is also the
 * delegated administrator account for Detective in Organizations.</p> <p>The
 * Detective administrator account can enable any organization account as a member
 * account in the organization behavior graph. The organization accounts do not
 * receive invitations. The Detective administrator account can also invite other
 * accounts to the organization behavior graph.</p> <p>Every behavior graph is
 * specific to a Region. You can only use the API to manage behavior graphs that
 * belong to the Region that is associated with the currently selected
 * endpoint.</p> <p>The administrator account for a behavior graph can use the
 * Detective API to do the following:</p> <ul> <li> <p>Enable and disable
 * Detective. Enabling Detective creates a new behavior graph.</p> </li> <li>
 * <p>View the list of member accounts in a behavior graph.</p> </li> <li> <p>Add
 * member accounts to a behavior graph.</p> </li> <li> <p>Remove member accounts
 * from a behavior graph.</p> </li> <li> <p>Apply tags to a behavior graph.</p>
 * </li> </ul> <p>The organization management account can use the Detective API to
 * select the delegated administrator for Detective.</p> <p>The Detective
 * administrator account for an organization can use the Detective API to do the
 * following:</p> <ul> <li> <p>Perform all of the functions of an administrator
 * account.</p> </li> <li> <p>Determine whether to automatically enable new
 * organization accounts as member accounts in the organization behavior graph.</p>
 * </li> </ul> <p>An invited member account can use the Detective API to do the
 * following:</p> <ul> <li> <p>View the list of behavior graphs that they are
 * invited to.</p> </li> <li> <p>Accept an invitation to contribute to a behavior
 * graph.</p> </li> <li> <p>Decline an invitation to contribute to a behavior
 * graph.</p> </li> <li> <p>Remove their account from a behavior graph.</p> </li>
 * </ul> <p>All API actions are logged as CloudTrail events. See <a
 * href="https://docs.aws.amazon.com/detective/latest/userguide/logging-using-cloudtrail.html">Logging
 * Detective API Calls with CloudTrail</a>.</p>  <p>We replaced the term
 * "master account" with the term "administrator account". An administrator account
 * is used to centrally manage multiple accounts. In the case of Detective, the
 * administrator account manages the accounts in their behavior graph.</p>
 */
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;

  /**
   * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client
   * config is not specified, it will be initialized to default values.
   */
  DetectiveClient(const Aws::Detective::DetectiveClientConfiguration& clientConfiguration = Aws::Detective::DetectiveClientConfiguration(),
                  std::shared_ptr<DetectiveEndpointProviderBase> endpointProvider = nullptr);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  DetectiveClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DetectiveEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Detective::DetectiveClientConfiguration& clientConfiguration = Aws::Detective::DetectiveClientConfiguration());

  /**
   * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
   * the default http client factory will be used
   */
  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 */
  /**
   * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client
   * config is not specified, it will be initialized to default values.
   */
  DetectiveClient(const Aws::Client::ClientConfiguration& clientConfiguration);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  DetectiveClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);

  /**
   * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
   * the default http client factory will be used
   */
  DetectiveClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);

  /* End of legacy constructors due deprecation */
  virtual ~DetectiveClient();

  /**
   * <p>Accepts an invitation for the member account to contribute data to a behavior
   * graph. This operation can only be called by an invited member account. </p>
   * <p>The request provides the ARN of behavior graph.</p> <p>The member account
   * status in the graph must be <code>INVITED</code>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/AcceptInvitation">AWS
   * API Reference</a></p>
   */
  virtual Model::AcceptInvitationOutcome AcceptInvitation(const Model::AcceptInvitationRequest& request) const;

  /**
   * A Callable wrapper for AcceptInvitation that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AcceptInvitationRequestT = Model::AcceptInvitationRequest>
  Model::AcceptInvitationOutcomeCallable AcceptInvitationCallable(const AcceptInvitationRequestT& request) const {
    return SubmitCallable(&DetectiveClient::AcceptInvitation, request);
  }

  /**
   * An Async wrapper for AcceptInvitation that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Gets data source package information for the behavior graph.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/BatchGetGraphMemberDatasources">AWS
   * API Reference</a></p>
   */
  virtual Model::BatchGetGraphMemberDatasourcesOutcome BatchGetGraphMemberDatasources(
      const Model::BatchGetGraphMemberDatasourcesRequest& request) const;

  /**
   * A Callable wrapper for BatchGetGraphMemberDatasources that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename BatchGetGraphMemberDatasourcesRequestT = Model::BatchGetGraphMemberDatasourcesRequest>
  Model::BatchGetGraphMemberDatasourcesOutcomeCallable BatchGetGraphMemberDatasourcesCallable(
      const BatchGetGraphMemberDatasourcesRequestT& request) const {
    return SubmitCallable(&DetectiveClient::BatchGetGraphMemberDatasources, request);
  }

  /**
   * An Async wrapper for BatchGetGraphMemberDatasources that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Gets information on the data source package history for an
   * account.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/BatchGetMembershipDatasources">AWS
   * API Reference</a></p>
   */
  virtual Model::BatchGetMembershipDatasourcesOutcome BatchGetMembershipDatasources(
      const Model::BatchGetMembershipDatasourcesRequest& request) const;

  /**
   * A Callable wrapper for BatchGetMembershipDatasources that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename BatchGetMembershipDatasourcesRequestT = Model::BatchGetMembershipDatasourcesRequest>
  Model::BatchGetMembershipDatasourcesOutcomeCallable BatchGetMembershipDatasourcesCallable(
      const BatchGetMembershipDatasourcesRequestT& request) const {
    return SubmitCallable(&DetectiveClient::BatchGetMembershipDatasources, request);
  }

  /**
   * An Async wrapper for BatchGetMembershipDatasources that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a new behavior graph for the calling account, and sets that account
   * as the administrator account. This operation is called by the account that is
   * enabling Detective.</p> <p>The operation also enables Detective for the calling
   * account in the currently selected Region. It returns the ARN of the new behavior
   * graph.</p> <p> <code>CreateGraph</code> triggers a process to create the
   * corresponding data tables for the new behavior graph.</p> <p>An account can only
   * be the administrator account for one behavior graph within a Region. If the same
   * account calls <code>CreateGraph</code> with the same administrator account, it
   * always returns the same behavior graph ARN. It does not create a new behavior
   * graph.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/CreateGraph">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateGraphOutcome CreateGraph(const Model::CreateGraphRequest& request = {}) const;

  /**
   * A Callable wrapper for CreateGraph that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateGraphRequestT = Model::CreateGraphRequest>
  Model::CreateGraphOutcomeCallable CreateGraphCallable(const CreateGraphRequestT& request = {}) const {
    return SubmitCallable(&DetectiveClient::CreateGraph, request);
  }

  /**
   * An Async wrapper for CreateGraph that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p> <code>CreateMembers</code> is used to send invitations to accounts. For the
   * organization behavior graph, the Detective administrator account uses
   * <code>CreateMembers</code> to enable organization accounts as member
   * accounts.</p> <p>For invited accounts, <code>CreateMembers</code> sends a
   * request to invite the specified Amazon Web Services accounts to be member
   * accounts in the behavior graph. This operation can only be called by the
   * administrator account for a behavior graph. </p> <p> <code>CreateMembers</code>
   * verifies the accounts and then invites the verified accounts. The administrator
   * can optionally specify to not send invitation emails to the member accounts.
   * This would be used when the administrator manages their member accounts
   * centrally.</p> <p>For organization accounts in the organization behavior graph,
   * <code>CreateMembers</code> attempts to enable the accounts. The organization
   * accounts do not receive invitations.</p> <p>The request provides the behavior
   * graph ARN and the list of accounts to invite or to enable.</p> <p>The response
   * separates the requested accounts into two lists:</p> <ul> <li> <p>The accounts
   * that <code>CreateMembers</code> was able to process. For invited accounts,
   * includes member accounts that are being verified, that have passed verification
   * and are to be invited, and that have failed verification. For organization
   * accounts in the organization behavior graph, includes accounts that can be
   * enabled and that cannot be enabled.</p> </li> <li> <p>The accounts that
   * <code>CreateMembers</code> was unable to process. This list includes accounts
   * that were already invited to be member accounts in the behavior graph.</p> </li>
   * </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/CreateMembers">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateMembersOutcome CreateMembers(const Model::CreateMembersRequest& request) const;

  /**
   * A Callable wrapper for CreateMembers that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateMembersRequestT = Model::CreateMembersRequest>
  Model::CreateMembersOutcomeCallable CreateMembersCallable(const CreateMembersRequestT& request) const {
    return SubmitCallable(&DetectiveClient::CreateMembers, request);
  }

  /**
   * An Async wrapper for CreateMembers that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Disables the specified behavior graph and queues it to be deleted. This
   * operation removes the behavior graph from each member account's list of behavior
   * graphs.</p> <p> <code>DeleteGraph</code> can only be called by the administrator
   * account for a behavior graph.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/DeleteGraph">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteGraphOutcome DeleteGraph(const Model::DeleteGraphRequest& request) const;

  /**
   * A Callable wrapper for DeleteGraph that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteGraphRequestT = Model::DeleteGraphRequest>
  Model::DeleteGraphOutcomeCallable DeleteGraphCallable(const DeleteGraphRequestT& request) const {
    return SubmitCallable(&DetectiveClient::DeleteGraph, request);
  }

  /**
   * An Async wrapper for DeleteGraph that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes the specified member accounts from the behavior graph. The removed
   * accounts no longer contribute data to the behavior graph. This operation can
   * only be called by the administrator account for the behavior graph.</p> <p>For
   * invited accounts, the removed accounts are deleted from the list of accounts in
   * the behavior graph. To restore the account, the administrator account must send
   * another invitation.</p> <p>For organization accounts in the organization
   * behavior graph, the Detective administrator account can always enable the
   * organization account again. Organization accounts that are not enabled as member
   * accounts are not included in the <code>ListMembers</code> results for the
   * organization behavior graph.</p> <p>An administrator account cannot use
   * <code>DeleteMembers</code> to remove their own account from the behavior graph.
   * To disable a behavior graph, the administrator account uses the
   * <code>DeleteGraph</code> API method.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/DeleteMembers">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteMembersOutcome DeleteMembers(const Model::DeleteMembersRequest& request) const;

  /**
   * A Callable wrapper for DeleteMembers that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteMembersRequestT = Model::DeleteMembersRequest>
  Model::DeleteMembersOutcomeCallable DeleteMembersCallable(const DeleteMembersRequestT& request) const {
    return SubmitCallable(&DetectiveClient::DeleteMembers, request);
  }

  /**
   * An Async wrapper for DeleteMembers that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Returns information about the configuration for the organization behavior
   * graph. Currently indicates whether to automatically enable new organization
   * accounts as member accounts.</p> <p>Can only be called by the Detective
   * administrator account for the organization. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/DescribeOrganizationConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeOrganizationConfigurationOutcome DescribeOrganizationConfiguration(
      const Model::DescribeOrganizationConfigurationRequest& request) const;

  /**
   * A Callable wrapper for DescribeOrganizationConfiguration that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DescribeOrganizationConfigurationRequestT = Model::DescribeOrganizationConfigurationRequest>
  Model::DescribeOrganizationConfigurationOutcomeCallable DescribeOrganizationConfigurationCallable(
      const DescribeOrganizationConfigurationRequestT& request) const {
    return SubmitCallable(&DetectiveClient::DescribeOrganizationConfiguration, request);
  }

  /**
   * An Async wrapper for DescribeOrganizationConfiguration that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the Detective administrator account in the current Region. Deletes
   * the organization behavior graph.</p> <p>Can only be called by the organization
   * management account.</p> <p>Removing the Detective administrator account does not
   * affect the delegated administrator account for Detective in Organizations.</p>
   * <p>To remove the delegated administrator account in Organizations, use the
   * Organizations API. Removing the delegated administrator account also removes the
   * Detective administrator account in all Regions, except for Regions where the
   * Detective administrator account is the organization management
   * account.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/DisableOrganizationAdminAccount">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableOrganizationAdminAccountOutcome DisableOrganizationAdminAccount(
      const Model::DisableOrganizationAdminAccountRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DisableOrganizationAdminAccountRequestT = Model::DisableOrganizationAdminAccountRequest>
  Model::DisableOrganizationAdminAccountOutcomeCallable DisableOrganizationAdminAccountCallable(
      const DisableOrganizationAdminAccountRequestT& request = {}) const {
    return SubmitCallable(&DetectiveClient::DisableOrganizationAdminAccount, request);
  }

  /**
   * An Async wrapper for DisableOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the member account from the specified behavior graph. This operation
   * can only be called by an invited member account that has the
   * <code>ENABLED</code> status.</p> <p> <code>DisassociateMembership</code> cannot
   * be called by an organization account in the organization behavior graph. For the
   * organization behavior graph, the Detective administrator account determines
   * which organization accounts to enable or disable as member
   * accounts.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/DisassociateMembership">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateMembershipOutcome DisassociateMembership(const Model::DisassociateMembershipRequest& request) const;

  /**
   * A Callable wrapper for DisassociateMembership that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisassociateMembershipRequestT = Model::DisassociateMembershipRequest>
  Model::DisassociateMembershipOutcomeCallable DisassociateMembershipCallable(const DisassociateMembershipRequestT& request) const {
    return SubmitCallable(&DetectiveClient::DisassociateMembership, request);
  }

  /**
   * An Async wrapper for DisassociateMembership that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Designates the Detective administrator account for the organization in the
   * current Region.</p> <p>If the account does not have Detective enabled, then
   * enables Detective for that account and creates a new behavior graph.</p> <p>Can
   * only be called by the organization management account.</p> <p>If the
   * organization has a delegated administrator account in Organizations, then the
   * Detective administrator account must be either the delegated administrator
   * account or the organization management account.</p> <p>If the organization does
   * not have a delegated administrator account in Organizations, then you can choose
   * any account in the organization. If you choose an account other than the
   * organization management account, Detective calls Organizations to make that
   * account the delegated administrator account for Detective. The organization
   * management account cannot be the delegated administrator account.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/EnableOrganizationAdminAccount">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableOrganizationAdminAccountOutcome EnableOrganizationAdminAccount(
      const Model::EnableOrganizationAdminAccountRequest& request) const;

  /**
   * A Callable wrapper for EnableOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename EnableOrganizationAdminAccountRequestT = Model::EnableOrganizationAdminAccountRequest>
  Model::EnableOrganizationAdminAccountOutcomeCallable EnableOrganizationAdminAccountCallable(
      const EnableOrganizationAdminAccountRequestT& request) const {
    return SubmitCallable(&DetectiveClient::EnableOrganizationAdminAccount, request);
  }

  /**
   * An Async wrapper for EnableOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Detective investigations lets you investigate IAM users and IAM roles using
   * indicators of compromise. An indicator of compromise (IOC) is an artifact
   * observed in or on a network, system, or environment that can (with a high level
   * of confidence) identify malicious activity or a security incident.
   * <code>GetInvestigation</code> returns the investigation results of an
   * investigation for a behavior graph. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/GetInvestigation">AWS
   * API Reference</a></p>
   */
  virtual Model::GetInvestigationOutcome GetInvestigation(const Model::GetInvestigationRequest& request) const;

  /**
   * A Callable wrapper for GetInvestigation that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetInvestigationRequestT = Model::GetInvestigationRequest>
  Model::GetInvestigationOutcomeCallable GetInvestigationCallable(const GetInvestigationRequestT& request) const {
    return SubmitCallable(&DetectiveClient::GetInvestigation, request);
  }

  /**
   * An Async wrapper for GetInvestigation that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Returns the membership details for specified member accounts for a behavior
   * graph.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/GetMembers">AWS
   * API Reference</a></p>
   */
  virtual Model::GetMembersOutcome GetMembers(const Model::GetMembersRequest& request) const;

  /**
   * A Callable wrapper for GetMembers that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename GetMembersRequestT = Model::GetMembersRequest>
  Model::GetMembersOutcomeCallable GetMembersCallable(const GetMembersRequestT& request) const {
    return SubmitCallable(&DetectiveClient::GetMembers, request);
  }

  /**
   * An Async wrapper for GetMembers that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists data source packages in the behavior graph.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListDatasourcePackages">AWS
   * API Reference</a></p>
   */
  virtual Model::ListDatasourcePackagesOutcome ListDatasourcePackages(const Model::ListDatasourcePackagesRequest& request) const;

  /**
   * A Callable wrapper for ListDatasourcePackages that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListDatasourcePackagesRequestT = Model::ListDatasourcePackagesRequest>
  Model::ListDatasourcePackagesOutcomeCallable ListDatasourcePackagesCallable(const ListDatasourcePackagesRequestT& request) const {
    return SubmitCallable(&DetectiveClient::ListDatasourcePackages, request);
  }

  /**
   * An Async wrapper for ListDatasourcePackages that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Returns the list of behavior graphs that the calling account is an
   * administrator account of. This operation can only be called by an administrator
   * account.</p> <p>Because an account can currently only be the administrator of
   * one behavior graph within a Region, the results always contain a single behavior
   * graph.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListGraphs">AWS
   * API Reference</a></p>
   */
  virtual Model::ListGraphsOutcome ListGraphs(const Model::ListGraphsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListGraphs that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListGraphsRequestT = Model::ListGraphsRequest>
  Model::ListGraphsOutcomeCallable ListGraphsCallable(const ListGraphsRequestT& request = {}) const {
    return SubmitCallable(&DetectiveClient::ListGraphs, request);
  }

  /**
   * An Async wrapper for ListGraphs that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Gets the indicators from an investigation. You can use the information from
   * the indicators to determine if an IAM user and/or IAM role is involved in an
   * unusual activity that could indicate malicious behavior and its
   * impact.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListIndicators">AWS
   * API Reference</a></p>
   */
  virtual Model::ListIndicatorsOutcome ListIndicators(const Model::ListIndicatorsRequest& request) const;

  /**
   * A Callable wrapper for ListIndicators that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListIndicatorsRequestT = Model::ListIndicatorsRequest>
  Model::ListIndicatorsOutcomeCallable ListIndicatorsCallable(const ListIndicatorsRequestT& request) const {
    return SubmitCallable(&DetectiveClient::ListIndicators, request);
  }

  /**
   * An Async wrapper for ListIndicators that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Detective investigations lets you investigate IAM users and IAM roles using
   * indicators of compromise. An indicator of compromise (IOC) is an artifact
   * observed in or on a network, system, or environment that can (with a high level
   * of confidence) identify malicious activity or a security incident.
   * <code>ListInvestigations</code> lists all active Detective
   * investigations.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListInvestigations">AWS
   * API Reference</a></p>
   */
  virtual Model::ListInvestigationsOutcome ListInvestigations(const Model::ListInvestigationsRequest& request) const;

  /**
   * A Callable wrapper for ListInvestigations that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
  Model::ListInvestigationsOutcomeCallable ListInvestigationsCallable(const ListInvestigationsRequestT& request) const {
    return SubmitCallable(&DetectiveClient::ListInvestigations, request);
  }

  /**
   * An Async wrapper for ListInvestigations that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Retrieves the list of open and accepted behavior graph invitations for the
   * member account. This operation can only be called by an invited member
   * account.</p> <p>Open invitations are invitations that the member account has not
   * responded to.</p> <p>The results do not include behavior graphs for which the
   * member account declined the invitation. The results also do not include behavior
   * graphs that the member account resigned from or was removed from.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListInvitations">AWS
   * API Reference</a></p>
   */
  virtual Model::ListInvitationsOutcome ListInvitations(const Model::ListInvitationsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListInvitations that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListInvitationsRequestT = Model::ListInvitationsRequest>
  Model::ListInvitationsOutcomeCallable ListInvitationsCallable(const ListInvitationsRequestT& request = {}) const {
    return SubmitCallable(&DetectiveClient::ListInvitations, request);
  }

  /**
   * An Async wrapper for ListInvitations that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Retrieves the list of member accounts for a behavior graph.</p> <p>For
   * invited accounts, the results do not include member accounts that were removed
   * from the behavior graph.</p> <p>For the organization behavior graph, the results
   * do not include organization accounts that the Detective administrator account
   * has not enabled as member accounts.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListMembers">AWS
   * API Reference</a></p>
   */
  virtual Model::ListMembersOutcome ListMembers(const Model::ListMembersRequest& request) const;

  /**
   * A Callable wrapper for ListMembers that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename ListMembersRequestT = Model::ListMembersRequest>
  Model::ListMembersOutcomeCallable ListMembersCallable(const ListMembersRequestT& request) const {
    return SubmitCallable(&DetectiveClient::ListMembers, request);
  }

  /**
   * An Async wrapper for ListMembers that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Returns information about the Detective administrator account for an
   * organization. Can only be called by the organization management
   * account.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListOrganizationAdminAccounts">AWS
   * API Reference</a></p>
   */
  virtual Model::ListOrganizationAdminAccountsOutcome ListOrganizationAdminAccounts(
      const Model::ListOrganizationAdminAccountsRequest& request = {}) const;

  /**
   * A Callable wrapper for ListOrganizationAdminAccounts that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListOrganizationAdminAccountsRequestT = Model::ListOrganizationAdminAccountsRequest>
  Model::ListOrganizationAdminAccountsOutcomeCallable ListOrganizationAdminAccountsCallable(
      const ListOrganizationAdminAccountsRequestT& request = {}) const {
    return SubmitCallable(&DetectiveClient::ListOrganizationAdminAccounts, request);
  }

  /**
   * An Async wrapper for ListOrganizationAdminAccounts that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Returns the tag values that are assigned to a behavior graph.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/ListTagsForResource">AWS
   * API Reference</a></p>
   */
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;

  /**
   * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&DetectiveClient::ListTagsForResource, request);
  }

  /**
   * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Rejects an invitation to contribute the account data to a behavior graph.
   * This operation must be called by an invited member account that has the
   * <code>INVITED</code> status.</p> <p> <code>RejectInvitation</code> cannot be
   * called by an organization account in the organization behavior graph. In the
   * organization behavior graph, organization accounts do not receive an
   * invitation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/RejectInvitation">AWS
   * API Reference</a></p>
   */
  virtual Model::RejectInvitationOutcome RejectInvitation(const Model::RejectInvitationRequest& request) const;

  /**
   * A Callable wrapper for RejectInvitation that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename RejectInvitationRequestT = Model::RejectInvitationRequest>
  Model::RejectInvitationOutcomeCallable RejectInvitationCallable(const RejectInvitationRequestT& request) const {
    return SubmitCallable(&DetectiveClient::RejectInvitation, request);
  }

  /**
   * An Async wrapper for RejectInvitation that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Detective investigations lets you investigate IAM users and IAM roles using
   * indicators of compromise. An indicator of compromise (IOC) is an artifact
   * observed in or on a network, system, or environment that can (with a high level
   * of confidence) identify malicious activity or a security incident.
   * <code>StartInvestigation</code> initiates an investigation on an entity in a
   * behavior graph. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/StartInvestigation">AWS
   * API Reference</a></p>
   */
  virtual Model::StartInvestigationOutcome StartInvestigation(const Model::StartInvestigationRequest& request) const;

  /**
   * A Callable wrapper for StartInvestigation that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename StartInvestigationRequestT = Model::StartInvestigationRequest>
  Model::StartInvestigationOutcomeCallable StartInvestigationCallable(const StartInvestigationRequestT& request) const {
    return SubmitCallable(&DetectiveClient::StartInvestigation, request);
  }

  /**
   * An Async wrapper for StartInvestigation that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Sends a request to enable data ingest for a member account that has a status
   * of <code>ACCEPTED_BUT_DISABLED</code>.</p> <p>For valid member accounts, the
   * status is updated as follows.</p> <ul> <li> <p>If Detective enabled the member
   * account, then the new status is <code>ENABLED</code>.</p> </li> <li> <p>If
   * Detective cannot enable the member account, the status remains
   * <code>ACCEPTED_BUT_DISABLED</code>. </p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/StartMonitoringMember">AWS
   * API Reference</a></p>
   */
  virtual Model::StartMonitoringMemberOutcome StartMonitoringMember(const Model::StartMonitoringMemberRequest& request) const;

  /**
   * A Callable wrapper for StartMonitoringMember that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename StartMonitoringMemberRequestT = Model::StartMonitoringMemberRequest>
  Model::StartMonitoringMemberOutcomeCallable StartMonitoringMemberCallable(const StartMonitoringMemberRequestT& request) const {
    return SubmitCallable(&DetectiveClient::StartMonitoringMember, request);
  }

  /**
   * An Async wrapper for StartMonitoringMember that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Applies tag values to a behavior graph.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/TagResource">AWS
   * API Reference</a></p>
   */
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;

  /**
   * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&DetectiveClient::TagResource, request);
  }

  /**
   * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes tags from a behavior graph.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/UntagResource">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;

  /**
   * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&DetectiveClient::UntagResource, request);
  }

  /**
   * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Starts a data source package for the Detective behavior graph.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/UpdateDatasourcePackages">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateDatasourcePackagesOutcome UpdateDatasourcePackages(const Model::UpdateDatasourcePackagesRequest& request) const;

  /**
   * A Callable wrapper for UpdateDatasourcePackages that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateDatasourcePackagesRequestT = Model::UpdateDatasourcePackagesRequest>
  Model::UpdateDatasourcePackagesOutcomeCallable UpdateDatasourcePackagesCallable(const UpdateDatasourcePackagesRequestT& request) const {
    return SubmitCallable(&DetectiveClient::UpdateDatasourcePackages, request);
  }

  /**
   * An Async wrapper for UpdateDatasourcePackages that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the state of an investigation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/UpdateInvestigationState">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateInvestigationStateOutcome UpdateInvestigationState(const Model::UpdateInvestigationStateRequest& request) const;

  /**
   * A Callable wrapper for UpdateInvestigationState that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateInvestigationStateRequestT = Model::UpdateInvestigationStateRequest>
  Model::UpdateInvestigationStateOutcomeCallable UpdateInvestigationStateCallable(const UpdateInvestigationStateRequestT& request) const {
    return SubmitCallable(&DetectiveClient::UpdateInvestigationState, request);
  }

  /**
   * An Async wrapper for UpdateInvestigationState that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the configuration for the Organizations integration in the current
   * Region. Can only be called by the Detective administrator account for the
   * organization.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/detective-2018-10-26/UpdateOrganizationConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateOrganizationConfigurationOutcome UpdateOrganizationConfiguration(
      const Model::UpdateOrganizationConfigurationRequest& request) const;

  /**
   * A Callable wrapper for UpdateOrganizationConfiguration that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename UpdateOrganizationConfigurationRequestT = Model::UpdateOrganizationConfigurationRequest>
  Model::UpdateOrganizationConfigurationOutcomeCallable UpdateOrganizationConfigurationCallable(
      const UpdateOrganizationConfigurationRequestT& request) const {
    return SubmitCallable(&DetectiveClient::UpdateOrganizationConfiguration, request);
  }

  /**
   * An Async wrapper for UpdateOrganizationConfiguration that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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
