ContinuumClient.h

 
#pragma once
#include <aws/continuum/ContinuumPaginationBase.h>
#include <aws/continuum/ContinuumServiceClientModel.h>
#include <aws/continuum/ContinuumWaiter.h>
#include <aws/continuum/Continuum_EXPORTS.h>
#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>
 
namespace Aws {
namespace Continuum {
class AWS_CONTINUUM_API ContinuumClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<ContinuumClient>,
                                          public ContinuumPaginationBase<ContinuumClient>,
                                          public ContinuumWaiter<ContinuumClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ContinuumClientConfiguration ClientConfigurationType;
  typedef ContinuumEndpointProvider EndpointProviderType;
 
  ContinuumClient(const Aws::Continuum::ContinuumClientConfiguration& clientConfiguration = Aws::Continuum::ContinuumClientConfiguration(),
                  std::shared_ptr<ContinuumEndpointProviderBase> endpointProvider = nullptr);
 
  ContinuumClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<ContinuumEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Continuum::ContinuumClientConfiguration& clientConfiguration = Aws::Continuum::ContinuumClientConfiguration());
 
  ContinuumClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<ContinuumEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Continuum::ContinuumClientConfiguration& clientConfiguration = Aws::Continuum::ContinuumClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ContinuumClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ContinuumClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ContinuumClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ContinuumClient();
 
  virtual Model::AssociateCollectorOutcome AssociateCollector(const Model::AssociateCollectorRequest& request) const;
 
  template <typename AssociateCollectorRequestT = Model::AssociateCollectorRequest>
  Model::AssociateCollectorOutcomeCallable AssociateCollectorCallable(const AssociateCollectorRequestT& request) const {
    return SubmitCallable(&ContinuumClient::AssociateCollector, request);
  }
 
  template <typename AssociateCollectorRequestT = Model::AssociateCollectorRequest>
  void AssociateCollectorAsync(const AssociateCollectorRequestT& request, const AssociateCollectorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::AssociateCollector, request, handler, context);
  }
 
  virtual Model::CreateCodeFindingOutcome CreateCodeFinding(const Model::CreateCodeFindingRequest& request) const;
 
  template <typename CreateCodeFindingRequestT = Model::CreateCodeFindingRequest>
  Model::CreateCodeFindingOutcomeCallable CreateCodeFindingCallable(const CreateCodeFindingRequestT& request) const {
    return SubmitCallable(&ContinuumClient::CreateCodeFinding, request);
  }
 
  template <typename CreateCodeFindingRequestT = Model::CreateCodeFindingRequest>
  void CreateCodeFindingAsync(const CreateCodeFindingRequestT& request, const CreateCodeFindingResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::CreateCodeFinding, request, handler, context);
  }
 
  virtual Model::CreateCodeScanOutcome CreateCodeScan(const Model::CreateCodeScanRequest& request) const;
 
  template <typename CreateCodeScanRequestT = Model::CreateCodeScanRequest>
  Model::CreateCodeScanOutcomeCallable CreateCodeScanCallable(const CreateCodeScanRequestT& request) const {
    return SubmitCallable(&ContinuumClient::CreateCodeScan, request);
  }
 
  template <typename CreateCodeScanRequestT = Model::CreateCodeScanRequest>
  void CreateCodeScanAsync(const CreateCodeScanRequestT& request, const CreateCodeScanResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::CreateCodeScan, request, handler, context);
  }
 
  virtual Model::CreateCollectorOutcome CreateCollector(const Model::CreateCollectorRequest& request = {}) const;
 
  template <typename CreateCollectorRequestT = Model::CreateCollectorRequest>
  Model::CreateCollectorOutcomeCallable CreateCollectorCallable(const CreateCollectorRequestT& request = {}) const {
    return SubmitCallable(&ContinuumClient::CreateCollector, request);
  }
 
  template <typename CreateCollectorRequestT = Model::CreateCollectorRequest>
  void CreateCollectorAsync(const CreateCollectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const CreateCollectorRequestT& request = {}) const {
    return SubmitAsync(&ContinuumClient::CreateCollector, request, handler, context);
  }
 
  virtual Model::CreateEnvironmentOutcome CreateEnvironment(const Model::CreateEnvironmentRequest& request) const;
 
  template <typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
  Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable(const CreateEnvironmentRequestT& request) const {
    return SubmitCallable(&ContinuumClient::CreateEnvironment, request);
  }
 
  template <typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
  void CreateEnvironmentAsync(const CreateEnvironmentRequestT& request, const CreateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::CreateEnvironment, request, handler, context);
  }
 
  virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const {
    return SubmitCallable(&ContinuumClient::CreateIntegration, request);
  }
 
  template <typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
  void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::CreateIntegration, request, handler, context);
  }
 
  virtual Model::DeleteCollectorOutcome DeleteCollector(const Model::DeleteCollectorRequest& request) const;
 
  template <typename DeleteCollectorRequestT = Model::DeleteCollectorRequest>
  Model::DeleteCollectorOutcomeCallable DeleteCollectorCallable(const DeleteCollectorRequestT& request) const {
    return SubmitCallable(&ContinuumClient::DeleteCollector, request);
  }
 
  template <typename DeleteCollectorRequestT = Model::DeleteCollectorRequest>
  void DeleteCollectorAsync(const DeleteCollectorRequestT& request, const DeleteCollectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::DeleteCollector, request, handler, context);
  }
 
  virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const;
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const {
    return SubmitCallable(&ContinuumClient::DeleteEnvironment, request);
  }
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::DeleteEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const {
    return SubmitCallable(&ContinuumClient::DeleteIntegration, request);
  }
 
  template <typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
  void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::DeleteIntegration, request, handler, context);
  }
 
  virtual Model::DisassociateCollectorOutcome DisassociateCollector(const Model::DisassociateCollectorRequest& request) const;
 
  template <typename DisassociateCollectorRequestT = Model::DisassociateCollectorRequest>
  Model::DisassociateCollectorOutcomeCallable DisassociateCollectorCallable(const DisassociateCollectorRequestT& request) const {
    return SubmitCallable(&ContinuumClient::DisassociateCollector, request);
  }
 
  template <typename DisassociateCollectorRequestT = Model::DisassociateCollectorRequest>
  void DisassociateCollectorAsync(const DisassociateCollectorRequestT& request, const DisassociateCollectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::DisassociateCollector, request, handler, context);
  }
 
  virtual Model::GetCodeFindingOutcome GetCodeFinding(const Model::GetCodeFindingRequest& request) const;
 
  template <typename GetCodeFindingRequestT = Model::GetCodeFindingRequest>
  Model::GetCodeFindingOutcomeCallable GetCodeFindingCallable(const GetCodeFindingRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetCodeFinding, request);
  }
 
  template <typename GetCodeFindingRequestT = Model::GetCodeFindingRequest>
  void GetCodeFindingAsync(const GetCodeFindingRequestT& request, const GetCodeFindingResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetCodeFinding, request, handler, context);
  }
 
  virtual Model::GetCodeIssueOutcome GetCodeIssue(const Model::GetCodeIssueRequest& request) const;
 
  template <typename GetCodeIssueRequestT = Model::GetCodeIssueRequest>
  Model::GetCodeIssueOutcomeCallable GetCodeIssueCallable(const GetCodeIssueRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetCodeIssue, request);
  }
 
  template <typename GetCodeIssueRequestT = Model::GetCodeIssueRequest>
  void GetCodeIssueAsync(const GetCodeIssueRequestT& request, const GetCodeIssueResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetCodeIssue, request, handler, context);
  }
 
  virtual Model::GetCodeIssueArtifactOutcome GetCodeIssueArtifact(const Model::GetCodeIssueArtifactRequest& request) const;
 
  template <typename GetCodeIssueArtifactRequestT = Model::GetCodeIssueArtifactRequest>
  Model::GetCodeIssueArtifactOutcomeCallable GetCodeIssueArtifactCallable(const GetCodeIssueArtifactRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetCodeIssueArtifact, request);
  }
 
  template <typename GetCodeIssueArtifactRequestT = Model::GetCodeIssueArtifactRequest>
  void GetCodeIssueArtifactAsync(const GetCodeIssueArtifactRequestT& request, const GetCodeIssueArtifactResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetCodeIssueArtifact, request, handler, context);
  }
 
  virtual Model::GetCodeScanOutcome GetCodeScan(const Model::GetCodeScanRequest& request) const;
 
  template <typename GetCodeScanRequestT = Model::GetCodeScanRequest>
  Model::GetCodeScanOutcomeCallable GetCodeScanCallable(const GetCodeScanRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetCodeScan, request);
  }
 
  template <typename GetCodeScanRequestT = Model::GetCodeScanRequest>
  void GetCodeScanAsync(const GetCodeScanRequestT& request, const GetCodeScanResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetCodeScan, request, handler, context);
  }
 
  virtual Model::GetCollectorOutcome GetCollector(const Model::GetCollectorRequest& request) const;
 
  template <typename GetCollectorRequestT = Model::GetCollectorRequest>
  Model::GetCollectorOutcomeCallable GetCollectorCallable(const GetCollectorRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetCollector, request);
  }
 
  template <typename GetCollectorRequestT = Model::GetCollectorRequest>
  void GetCollectorAsync(const GetCollectorRequestT& request, const GetCollectorResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetCollector, request, handler, context);
  }
 
  virtual Model::GetCollectorDataAccessAuthorizationOutcome GetCollectorDataAccessAuthorization(
      const Model::GetCollectorDataAccessAuthorizationRequest& request) const;
 
  template <typename GetCollectorDataAccessAuthorizationRequestT = Model::GetCollectorDataAccessAuthorizationRequest>
  Model::GetCollectorDataAccessAuthorizationOutcomeCallable GetCollectorDataAccessAuthorizationCallable(
      const GetCollectorDataAccessAuthorizationRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetCollectorDataAccessAuthorization, request);
  }
 
  template <typename GetCollectorDataAccessAuthorizationRequestT = Model::GetCollectorDataAccessAuthorizationRequest>
  void GetCollectorDataAccessAuthorizationAsync(const GetCollectorDataAccessAuthorizationRequestT& request,
                                                const GetCollectorDataAccessAuthorizationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetCollectorDataAccessAuthorization, request, handler, context);
  }
 
  virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const;
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetEnvironment, request);
  }
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetEnvironment, request, handler, context);
  }
 
  virtual Model::GetIntegrationOutcome GetIntegration(const Model::GetIntegrationRequest& request) const;
 
  template <typename GetIntegrationRequestT = Model::GetIntegrationRequest>
  Model::GetIntegrationOutcomeCallable GetIntegrationCallable(const GetIntegrationRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetIntegration, request);
  }
 
  template <typename GetIntegrationRequestT = Model::GetIntegrationRequest>
  void GetIntegrationAsync(const GetIntegrationRequestT& request, const GetIntegrationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetIntegration, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&ContinuumClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::ListAssociatedCollectorsOutcome ListAssociatedCollectors(const Model::ListAssociatedCollectorsRequest& request) const;
 
  template <typename ListAssociatedCollectorsRequestT = Model::ListAssociatedCollectorsRequest>
  Model::ListAssociatedCollectorsOutcomeCallable ListAssociatedCollectorsCallable(const ListAssociatedCollectorsRequestT& request) const {
    return SubmitCallable(&ContinuumClient::ListAssociatedCollectors, request);
  }
 
  template <typename ListAssociatedCollectorsRequestT = Model::ListAssociatedCollectorsRequest>
  void ListAssociatedCollectorsAsync(const ListAssociatedCollectorsRequestT& request,
                                     const ListAssociatedCollectorsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::ListAssociatedCollectors, request, handler, context);
  }
 
  virtual Model::ListAssociatedEnvironmentsOutcome ListAssociatedEnvironments(
      const Model::ListAssociatedEnvironmentsRequest& request) const;
 
  template <typename ListAssociatedEnvironmentsRequestT = Model::ListAssociatedEnvironmentsRequest>
  Model::ListAssociatedEnvironmentsOutcomeCallable ListAssociatedEnvironmentsCallable(
      const ListAssociatedEnvironmentsRequestT& request) const {
    return SubmitCallable(&ContinuumClient::ListAssociatedEnvironments, request);
  }
 
  template <typename ListAssociatedEnvironmentsRequestT = Model::ListAssociatedEnvironmentsRequest>
  void ListAssociatedEnvironmentsAsync(const ListAssociatedEnvironmentsRequestT& request,
                                       const ListAssociatedEnvironmentsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::ListAssociatedEnvironments, request, handler, context);
  }
 
  virtual Model::ListCodeFindingsOutcome ListCodeFindings(const Model::ListCodeFindingsRequest& request) const;
 
  template <typename ListCodeFindingsRequestT = Model::ListCodeFindingsRequest>
  Model::ListCodeFindingsOutcomeCallable ListCodeFindingsCallable(const ListCodeFindingsRequestT& request) const {
    return SubmitCallable(&ContinuumClient::ListCodeFindings, request);
  }
 
  template <typename ListCodeFindingsRequestT = Model::ListCodeFindingsRequest>
  void ListCodeFindingsAsync(const ListCodeFindingsRequestT& request, const ListCodeFindingsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::ListCodeFindings, request, handler, context);
  }
 
  virtual Model::ListCodeIssueArtifactsOutcome ListCodeIssueArtifacts(const Model::ListCodeIssueArtifactsRequest& request) const;
 
  template <typename ListCodeIssueArtifactsRequestT = Model::ListCodeIssueArtifactsRequest>
  Model::ListCodeIssueArtifactsOutcomeCallable ListCodeIssueArtifactsCallable(const ListCodeIssueArtifactsRequestT& request) const {
    return SubmitCallable(&ContinuumClient::ListCodeIssueArtifacts, request);
  }
 
  template <typename ListCodeIssueArtifactsRequestT = Model::ListCodeIssueArtifactsRequest>
  void ListCodeIssueArtifactsAsync(const ListCodeIssueArtifactsRequestT& request,
                                   const ListCodeIssueArtifactsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::ListCodeIssueArtifacts, request, handler, context);
  }
 
  virtual Model::ListCodeIssuesOutcome ListCodeIssues(const Model::ListCodeIssuesRequest& request) const;
 
  template <typename ListCodeIssuesRequestT = Model::ListCodeIssuesRequest>
  Model::ListCodeIssuesOutcomeCallable ListCodeIssuesCallable(const ListCodeIssuesRequestT& request) const {
    return SubmitCallable(&ContinuumClient::ListCodeIssues, request);
  }
 
  template <typename ListCodeIssuesRequestT = Model::ListCodeIssuesRequest>
  void ListCodeIssuesAsync(const ListCodeIssuesRequestT& request, const ListCodeIssuesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::ListCodeIssues, request, handler, context);
  }
 
  virtual Model::ListCodeScansOutcome ListCodeScans(const Model::ListCodeScansRequest& request) const;
 
  template <typename ListCodeScansRequestT = Model::ListCodeScansRequest>
  Model::ListCodeScansOutcomeCallable ListCodeScansCallable(const ListCodeScansRequestT& request) const {
    return SubmitCallable(&ContinuumClient::ListCodeScans, request);
  }
 
  template <typename ListCodeScansRequestT = Model::ListCodeScansRequest>
  void ListCodeScansAsync(const ListCodeScansRequestT& request, const ListCodeScansResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::ListCodeScans, request, handler, context);
  }
 
  virtual Model::ListCollectorsOutcome ListCollectors(const Model::ListCollectorsRequest& request = {}) const;
 
  template <typename ListCollectorsRequestT = Model::ListCollectorsRequest>
  Model::ListCollectorsOutcomeCallable ListCollectorsCallable(const ListCollectorsRequestT& request = {}) const {
    return SubmitCallable(&ContinuumClient::ListCollectors, request);
  }
 
  template <typename ListCollectorsRequestT = Model::ListCollectorsRequest>
  void ListCollectorsAsync(const ListCollectorsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListCollectorsRequestT& request = {}) const {
    return SubmitAsync(&ContinuumClient::ListCollectors, request, handler, context);
  }
 
  virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request = {}) const;
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request = {}) const {
    return SubmitCallable(&ContinuumClient::ListEnvironments, request);
  }
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  void ListEnvironmentsAsync(const ListEnvironmentsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListEnvironmentsRequestT& request = {}) const {
    return SubmitAsync(&ContinuumClient::ListEnvironments, request, handler, context);
  }
 
  virtual Model::ListIntegrationsOutcome ListIntegrations(const Model::ListIntegrationsRequest& request = {}) const;
 
  template <typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
  Model::ListIntegrationsOutcomeCallable ListIntegrationsCallable(const ListIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&ContinuumClient::ListIntegrations, request);
  }
 
  template <typename ListIntegrationsRequestT = Model::ListIntegrationsRequest>
  void ListIntegrationsAsync(const ListIntegrationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&ContinuumClient::ListIntegrations, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&ContinuumClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::StartIntegrationAuthorizationOutcome StartIntegrationAuthorization(
      const Model::StartIntegrationAuthorizationRequest& request) const;
 
  template <typename StartIntegrationAuthorizationRequestT = Model::StartIntegrationAuthorizationRequest>
  Model::StartIntegrationAuthorizationOutcomeCallable StartIntegrationAuthorizationCallable(
      const StartIntegrationAuthorizationRequestT& request) const {
    return SubmitCallable(&ContinuumClient::StartIntegrationAuthorization, request);
  }
 
  template <typename StartIntegrationAuthorizationRequestT = Model::StartIntegrationAuthorizationRequest>
  void StartIntegrationAuthorizationAsync(const StartIntegrationAuthorizationRequestT& request,
                                          const StartIntegrationAuthorizationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::StartIntegrationAuthorization, request, handler, context);
  }
 
  virtual Model::UpdateCollectorOutcome UpdateCollector(const Model::UpdateCollectorRequest& request) const;
 
  template <typename UpdateCollectorRequestT = Model::UpdateCollectorRequest>
  Model::UpdateCollectorOutcomeCallable UpdateCollectorCallable(const UpdateCollectorRequestT& request) const {
    return SubmitCallable(&ContinuumClient::UpdateCollector, request);
  }
 
  template <typename UpdateCollectorRequestT = Model::UpdateCollectorRequest>
  void UpdateCollectorAsync(const UpdateCollectorRequestT& request, const UpdateCollectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::UpdateCollector, request, handler, context);
  }
 
  virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const;
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const {
    return SubmitCallable(&ContinuumClient::UpdateEnvironment, request);
  }
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::UpdateEnvironment, request, handler, context);
  }
 
  virtual Model::UpdateIntegrationOutcome UpdateIntegration(const Model::UpdateIntegrationRequest& request) const;
 
  template <typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
  Model::UpdateIntegrationOutcomeCallable UpdateIntegrationCallable(const UpdateIntegrationRequestT& request) const {
    return SubmitCallable(&ContinuumClient::UpdateIntegration, request);
  }
 
  template <typename UpdateIntegrationRequestT = Model::UpdateIntegrationRequest>
  void UpdateIntegrationAsync(const UpdateIntegrationRequestT& request, const UpdateIntegrationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ContinuumClient::UpdateIntegration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ContinuumEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ContinuumClient>;
  void init(const ContinuumClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ContinuumError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ContinuumClientConfiguration m_clientConfiguration;
  std::shared_ptr<ContinuumEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Continuum
}  // namespace Aws