Resiliencehubv2Client.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/resiliencehubv2/Resiliencehubv2PaginationBase.h>
#include <aws/resiliencehubv2/Resiliencehubv2ServiceClientModel.h>
#include <aws/resiliencehubv2/Resiliencehubv2Waiter.h>
#include <aws/resiliencehubv2/Resiliencehubv2_EXPORTS.h>
 
namespace Aws {
namespace resiliencehubv2 {
class AWS_RESILIENCEHUBV2_API Resiliencehubv2Client : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<Resiliencehubv2Client>,
                                                      public Resiliencehubv2PaginationBase<Resiliencehubv2Client>,
                                                      public Resiliencehubv2Waiter<Resiliencehubv2Client> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Resiliencehubv2ClientConfiguration ClientConfigurationType;
  typedef Resiliencehubv2EndpointProvider EndpointProviderType;
 
  Resiliencehubv2Client(const Aws::resiliencehubv2::Resiliencehubv2ClientConfiguration& clientConfiguration =
                            Aws::resiliencehubv2::Resiliencehubv2ClientConfiguration(),
                        std::shared_ptr<Resiliencehubv2EndpointProviderBase> endpointProvider = nullptr);
 
  Resiliencehubv2Client(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<Resiliencehubv2EndpointProviderBase> endpointProvider = nullptr,
                        const Aws::resiliencehubv2::Resiliencehubv2ClientConfiguration& clientConfiguration =
                            Aws::resiliencehubv2::Resiliencehubv2ClientConfiguration());
 
  Resiliencehubv2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<Resiliencehubv2EndpointProviderBase> endpointProvider = nullptr,
                        const Aws::resiliencehubv2::Resiliencehubv2ClientConfiguration& clientConfiguration =
                            Aws::resiliencehubv2::Resiliencehubv2ClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Resiliencehubv2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Resiliencehubv2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Resiliencehubv2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Resiliencehubv2Client();
 
  virtual Model::CreateAssertionOutcome CreateAssertion(const Model::CreateAssertionRequest& request) const;
 
  template <typename CreateAssertionRequestT = Model::CreateAssertionRequest>
  Model::CreateAssertionOutcomeCallable CreateAssertionCallable(const CreateAssertionRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateAssertion, request);
  }
 
  template <typename CreateAssertionRequestT = Model::CreateAssertionRequest>
  void CreateAssertionAsync(const CreateAssertionRequestT& request, const CreateAssertionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateAssertion, request, handler, context);
  }
 
  virtual Model::CreateInputSourceOutcome CreateInputSource(const Model::CreateInputSourceRequest& request) const;
 
  template <typename CreateInputSourceRequestT = Model::CreateInputSourceRequest>
  Model::CreateInputSourceOutcomeCallable CreateInputSourceCallable(const CreateInputSourceRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateInputSource, request);
  }
 
  template <typename CreateInputSourceRequestT = Model::CreateInputSourceRequest>
  void CreateInputSourceAsync(const CreateInputSourceRequestT& request, const CreateInputSourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateInputSource, request, handler, context);
  }
 
  virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const;
 
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreatePolicy, request);
  }
 
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreatePolicy, request, handler, context);
  }
 
  virtual Model::CreateReportOutcome CreateReport(const Model::CreateReportRequest& request) const;
 
  template <typename CreateReportRequestT = Model::CreateReportRequest>
  Model::CreateReportOutcomeCallable CreateReportCallable(const CreateReportRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateReport, request);
  }
 
  template <typename CreateReportRequestT = Model::CreateReportRequest>
  void CreateReportAsync(const CreateReportRequestT& request, const CreateReportResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateReport, request, handler, context);
  }
 
  virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const;
 
  template <typename CreateServiceRequestT = Model::CreateServiceRequest>
  Model::CreateServiceOutcomeCallable CreateServiceCallable(const CreateServiceRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateService, request);
  }
 
  template <typename CreateServiceRequestT = Model::CreateServiceRequest>
  void CreateServiceAsync(const CreateServiceRequestT& request, const CreateServiceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateService, request, handler, context);
  }
 
  virtual Model::CreateServiceFunctionOutcome CreateServiceFunction(const Model::CreateServiceFunctionRequest& request) const;
 
  template <typename CreateServiceFunctionRequestT = Model::CreateServiceFunctionRequest>
  Model::CreateServiceFunctionOutcomeCallable CreateServiceFunctionCallable(const CreateServiceFunctionRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateServiceFunction, request);
  }
 
  template <typename CreateServiceFunctionRequestT = Model::CreateServiceFunctionRequest>
  void CreateServiceFunctionAsync(const CreateServiceFunctionRequestT& request, const CreateServiceFunctionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateServiceFunction, request, handler, context);
  }
 
  virtual Model::CreateServiceFunctionResourcesOutcome CreateServiceFunctionResources(
      const Model::CreateServiceFunctionResourcesRequest& request) const;
 
  template <typename CreateServiceFunctionResourcesRequestT = Model::CreateServiceFunctionResourcesRequest>
  Model::CreateServiceFunctionResourcesOutcomeCallable CreateServiceFunctionResourcesCallable(
      const CreateServiceFunctionResourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateServiceFunctionResources, request);
  }
 
  template <typename CreateServiceFunctionResourcesRequestT = Model::CreateServiceFunctionResourcesRequest>
  void CreateServiceFunctionResourcesAsync(const CreateServiceFunctionResourcesRequestT& request,
                                           const CreateServiceFunctionResourcesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateServiceFunctionResources, request, handler, context);
  }
 
  virtual Model::CreateSystemOutcome CreateSystem(const Model::CreateSystemRequest& request) const;
 
  template <typename CreateSystemRequestT = Model::CreateSystemRequest>
  Model::CreateSystemOutcomeCallable CreateSystemCallable(const CreateSystemRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateSystem, request);
  }
 
  template <typename CreateSystemRequestT = Model::CreateSystemRequest>
  void CreateSystemAsync(const CreateSystemRequestT& request, const CreateSystemResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateSystem, request, handler, context);
  }
 
  virtual Model::CreateTestOutcome CreateTest(const Model::CreateTestRequest& request) const;
 
  template <typename CreateTestRequestT = Model::CreateTestRequest>
  Model::CreateTestOutcomeCallable CreateTestCallable(const CreateTestRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateTest, request);
  }
 
  template <typename CreateTestRequestT = Model::CreateTestRequest>
  void CreateTestAsync(const CreateTestRequestT& request, const CreateTestResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateTest, request, handler, context);
  }
 
  virtual Model::CreateUserJourneyOutcome CreateUserJourney(const Model::CreateUserJourneyRequest& request) const;
 
  template <typename CreateUserJourneyRequestT = Model::CreateUserJourneyRequest>
  Model::CreateUserJourneyOutcomeCallable CreateUserJourneyCallable(const CreateUserJourneyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::CreateUserJourney, request);
  }
 
  template <typename CreateUserJourneyRequestT = Model::CreateUserJourneyRequest>
  void CreateUserJourneyAsync(const CreateUserJourneyRequestT& request, const CreateUserJourneyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::CreateUserJourney, request, handler, context);
  }
 
  virtual Model::DeleteAssertionOutcome DeleteAssertion(const Model::DeleteAssertionRequest& request) const;
 
  template <typename DeleteAssertionRequestT = Model::DeleteAssertionRequest>
  Model::DeleteAssertionOutcomeCallable DeleteAssertionCallable(const DeleteAssertionRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteAssertion, request);
  }
 
  template <typename DeleteAssertionRequestT = Model::DeleteAssertionRequest>
  void DeleteAssertionAsync(const DeleteAssertionRequestT& request, const DeleteAssertionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteAssertion, request, handler, context);
  }
 
  virtual Model::DeleteInputSourceOutcome DeleteInputSource(const Model::DeleteInputSourceRequest& request) const;
 
  template <typename DeleteInputSourceRequestT = Model::DeleteInputSourceRequest>
  Model::DeleteInputSourceOutcomeCallable DeleteInputSourceCallable(const DeleteInputSourceRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteInputSource, request);
  }
 
  template <typename DeleteInputSourceRequestT = Model::DeleteInputSourceRequest>
  void DeleteInputSourceAsync(const DeleteInputSourceRequestT& request, const DeleteInputSourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteInputSource, request, handler, context);
  }
 
  virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeletePolicy, request);
  }
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeletePolicy, request, handler, context);
  }
 
  virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const;
 
  template <typename DeleteServiceRequestT = Model::DeleteServiceRequest>
  Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const DeleteServiceRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteService, request);
  }
 
  template <typename DeleteServiceRequestT = Model::DeleteServiceRequest>
  void DeleteServiceAsync(const DeleteServiceRequestT& request, const DeleteServiceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteService, request, handler, context);
  }
 
  virtual Model::DeleteServiceFunctionOutcome DeleteServiceFunction(const Model::DeleteServiceFunctionRequest& request) const;
 
  template <typename DeleteServiceFunctionRequestT = Model::DeleteServiceFunctionRequest>
  Model::DeleteServiceFunctionOutcomeCallable DeleteServiceFunctionCallable(const DeleteServiceFunctionRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteServiceFunction, request);
  }
 
  template <typename DeleteServiceFunctionRequestT = Model::DeleteServiceFunctionRequest>
  void DeleteServiceFunctionAsync(const DeleteServiceFunctionRequestT& request, const DeleteServiceFunctionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteServiceFunction, request, handler, context);
  }
 
  virtual Model::DeleteServiceFunctionResourcesOutcome DeleteServiceFunctionResources(
      const Model::DeleteServiceFunctionResourcesRequest& request) const;
 
  template <typename DeleteServiceFunctionResourcesRequestT = Model::DeleteServiceFunctionResourcesRequest>
  Model::DeleteServiceFunctionResourcesOutcomeCallable DeleteServiceFunctionResourcesCallable(
      const DeleteServiceFunctionResourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteServiceFunctionResources, request);
  }
 
  template <typename DeleteServiceFunctionResourcesRequestT = Model::DeleteServiceFunctionResourcesRequest>
  void DeleteServiceFunctionResourcesAsync(const DeleteServiceFunctionResourcesRequestT& request,
                                           const DeleteServiceFunctionResourcesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteServiceFunctionResources, request, handler, context);
  }
 
  virtual Model::DeleteSystemOutcome DeleteSystem(const Model::DeleteSystemRequest& request) const;
 
  template <typename DeleteSystemRequestT = Model::DeleteSystemRequest>
  Model::DeleteSystemOutcomeCallable DeleteSystemCallable(const DeleteSystemRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteSystem, request);
  }
 
  template <typename DeleteSystemRequestT = Model::DeleteSystemRequest>
  void DeleteSystemAsync(const DeleteSystemRequestT& request, const DeleteSystemResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteSystem, request, handler, context);
  }
 
  virtual Model::DeleteTestOutcome DeleteTest(const Model::DeleteTestRequest& request) const;
 
  template <typename DeleteTestRequestT = Model::DeleteTestRequest>
  Model::DeleteTestOutcomeCallable DeleteTestCallable(const DeleteTestRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteTest, request);
  }
 
  template <typename DeleteTestRequestT = Model::DeleteTestRequest>
  void DeleteTestAsync(const DeleteTestRequestT& request, const DeleteTestResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteTest, request, handler, context);
  }
 
  virtual Model::DeleteTestSourcesOutcome DeleteTestSources(const Model::DeleteTestSourcesRequest& request) const;
 
  template <typename DeleteTestSourcesRequestT = Model::DeleteTestSourcesRequest>
  Model::DeleteTestSourcesOutcomeCallable DeleteTestSourcesCallable(const DeleteTestSourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteTestSources, request);
  }
 
  template <typename DeleteTestSourcesRequestT = Model::DeleteTestSourcesRequest>
  void DeleteTestSourcesAsync(const DeleteTestSourcesRequestT& request, const DeleteTestSourcesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteTestSources, request, handler, context);
  }
 
  virtual Model::DeleteUserJourneyOutcome DeleteUserJourney(const Model::DeleteUserJourneyRequest& request) const;
 
  template <typename DeleteUserJourneyRequestT = Model::DeleteUserJourneyRequest>
  Model::DeleteUserJourneyOutcomeCallable DeleteUserJourneyCallable(const DeleteUserJourneyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::DeleteUserJourney, request);
  }
 
  template <typename DeleteUserJourneyRequestT = Model::DeleteUserJourneyRequest>
  void DeleteUserJourneyAsync(const DeleteUserJourneyRequestT& request, const DeleteUserJourneyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::DeleteUserJourney, request, handler, context);
  }
 
  virtual Model::GetFailureModeFindingOutcome GetFailureModeFinding(const Model::GetFailureModeFindingRequest& request) const;
 
  template <typename GetFailureModeFindingRequestT = Model::GetFailureModeFindingRequest>
  Model::GetFailureModeFindingOutcomeCallable GetFailureModeFindingCallable(const GetFailureModeFindingRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetFailureModeFinding, request);
  }
 
  template <typename GetFailureModeFindingRequestT = Model::GetFailureModeFindingRequest>
  void GetFailureModeFindingAsync(const GetFailureModeFindingRequestT& request, const GetFailureModeFindingResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetFailureModeFinding, request, handler, context);
  }
 
  virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetPolicy, request);
  }
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetPolicy, request, handler, context);
  }
 
  virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
  template <typename GetServiceRequestT = Model::GetServiceRequest>
  Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetService, request);
  }
 
  template <typename GetServiceRequestT = Model::GetServiceRequest>
  void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetService, request, handler, context);
  }
 
  virtual Model::GetSystemOutcome GetSystem(const Model::GetSystemRequest& request) const;
 
  template <typename GetSystemRequestT = Model::GetSystemRequest>
  Model::GetSystemOutcomeCallable GetSystemCallable(const GetSystemRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetSystem, request);
  }
 
  template <typename GetSystemRequestT = Model::GetSystemRequest>
  void GetSystemAsync(const GetSystemRequestT& request, const GetSystemResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetSystem, request, handler, context);
  }
 
  virtual Model::GetTestOutcome GetTest(const Model::GetTestRequest& request) const;
 
  template <typename GetTestRequestT = Model::GetTestRequest>
  Model::GetTestOutcomeCallable GetTestCallable(const GetTestRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetTest, request);
  }
 
  template <typename GetTestRequestT = Model::GetTestRequest>
  void GetTestAsync(const GetTestRequestT& request, const GetTestResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetTest, request, handler, context);
  }
 
  virtual Model::GetTestRunOutcome GetTestRun(const Model::GetTestRunRequest& request) const;
 
  template <typename GetTestRunRequestT = Model::GetTestRunRequest>
  Model::GetTestRunOutcomeCallable GetTestRunCallable(const GetTestRunRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetTestRun, request);
  }
 
  template <typename GetTestRunRequestT = Model::GetTestRunRequest>
  void GetTestRunAsync(const GetTestRunRequestT& request, const GetTestRunResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetTestRun, request, handler, context);
  }
 
  virtual Model::GetTestTemplateOutcome GetTestTemplate(const Model::GetTestTemplateRequest& request) const;
 
  template <typename GetTestTemplateRequestT = Model::GetTestTemplateRequest>
  Model::GetTestTemplateOutcomeCallable GetTestTemplateCallable(const GetTestTemplateRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetTestTemplate, request);
  }
 
  template <typename GetTestTemplateRequestT = Model::GetTestTemplateRequest>
  void GetTestTemplateAsync(const GetTestTemplateRequestT& request, const GetTestTemplateResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetTestTemplate, request, handler, context);
  }
 
  virtual Model::GetUserJourneyOutcome GetUserJourney(const Model::GetUserJourneyRequest& request) const;
 
  template <typename GetUserJourneyRequestT = Model::GetUserJourneyRequest>
  Model::GetUserJourneyOutcomeCallable GetUserJourneyCallable(const GetUserJourneyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::GetUserJourney, request);
  }
 
  template <typename GetUserJourneyRequestT = Model::GetUserJourneyRequest>
  void GetUserJourneyAsync(const GetUserJourneyRequestT& request, const GetUserJourneyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::GetUserJourney, request, handler, context);
  }
 
  virtual Model::ImportAppOutcome ImportApp(const Model::ImportAppRequest& request) const;
 
  template <typename ImportAppRequestT = Model::ImportAppRequest>
  Model::ImportAppOutcomeCallable ImportAppCallable(const ImportAppRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ImportApp, request);
  }
 
  template <typename ImportAppRequestT = Model::ImportAppRequest>
  void ImportAppAsync(const ImportAppRequestT& request, const ImportAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ImportApp, request, handler, context);
  }
 
  virtual Model::ImportPolicyOutcome ImportPolicy(const Model::ImportPolicyRequest& request) const;
 
  template <typename ImportPolicyRequestT = Model::ImportPolicyRequest>
  Model::ImportPolicyOutcomeCallable ImportPolicyCallable(const ImportPolicyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ImportPolicy, request);
  }
 
  template <typename ImportPolicyRequestT = Model::ImportPolicyRequest>
  void ImportPolicyAsync(const ImportPolicyRequestT& request, const ImportPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ImportPolicy, request, handler, context);
  }
 
  virtual Model::ListAssertionsOutcome ListAssertions(const Model::ListAssertionsRequest& request) const;
 
  template <typename ListAssertionsRequestT = Model::ListAssertionsRequest>
  Model::ListAssertionsOutcomeCallable ListAssertionsCallable(const ListAssertionsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListAssertions, request);
  }
 
  template <typename ListAssertionsRequestT = Model::ListAssertionsRequest>
  void ListAssertionsAsync(const ListAssertionsRequestT& request, const ListAssertionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListAssertions, request, handler, context);
  }
 
  virtual Model::ListDependenciesOutcome ListDependencies(const Model::ListDependenciesRequest& request = {}) const;
 
  template <typename ListDependenciesRequestT = Model::ListDependenciesRequest>
  Model::ListDependenciesOutcomeCallable ListDependenciesCallable(const ListDependenciesRequestT& request = {}) const {
    return SubmitCallable(&Resiliencehubv2Client::ListDependencies, request);
  }
 
  template <typename ListDependenciesRequestT = Model::ListDependenciesRequest>
  void ListDependenciesAsync(const ListDependenciesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListDependenciesRequestT& request = {}) const {
    return SubmitAsync(&Resiliencehubv2Client::ListDependencies, request, handler, context);
  }
 
  virtual Model::ListFailureModeAssessmentsOutcome ListFailureModeAssessments(
      const Model::ListFailureModeAssessmentsRequest& request) const;
 
  template <typename ListFailureModeAssessmentsRequestT = Model::ListFailureModeAssessmentsRequest>
  Model::ListFailureModeAssessmentsOutcomeCallable ListFailureModeAssessmentsCallable(
      const ListFailureModeAssessmentsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListFailureModeAssessments, request);
  }
 
  template <typename ListFailureModeAssessmentsRequestT = Model::ListFailureModeAssessmentsRequest>
  void ListFailureModeAssessmentsAsync(const ListFailureModeAssessmentsRequestT& request,
                                       const ListFailureModeAssessmentsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListFailureModeAssessments, request, handler, context);
  }
 
  virtual Model::ListFailureModeFindingsOutcome ListFailureModeFindings(const Model::ListFailureModeFindingsRequest& request) const;
 
  template <typename ListFailureModeFindingsRequestT = Model::ListFailureModeFindingsRequest>
  Model::ListFailureModeFindingsOutcomeCallable ListFailureModeFindingsCallable(const ListFailureModeFindingsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListFailureModeFindings, request);
  }
 
  template <typename ListFailureModeFindingsRequestT = Model::ListFailureModeFindingsRequest>
  void ListFailureModeFindingsAsync(const ListFailureModeFindingsRequestT& request,
                                    const ListFailureModeFindingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListFailureModeFindings, request, handler, context);
  }
 
  virtual Model::ListInputSourcesOutcome ListInputSources(const Model::ListInputSourcesRequest& request) const;
 
  template <typename ListInputSourcesRequestT = Model::ListInputSourcesRequest>
  Model::ListInputSourcesOutcomeCallable ListInputSourcesCallable(const ListInputSourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListInputSources, request);
  }
 
  template <typename ListInputSourcesRequestT = Model::ListInputSourcesRequest>
  void ListInputSourcesAsync(const ListInputSourcesRequestT& request, const ListInputSourcesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListInputSources, request, handler, context);
  }
 
  virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request = {}) const;
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request = {}) const {
    return SubmitCallable(&Resiliencehubv2Client::ListPolicies, request);
  }
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  void ListPoliciesAsync(const ListPoliciesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListPoliciesRequestT& request = {}) const {
    return SubmitAsync(&Resiliencehubv2Client::ListPolicies, request, handler, context);
  }
 
  virtual Model::ListReportsOutcome ListReports(const Model::ListReportsRequest& request = {}) const;
 
  template <typename ListReportsRequestT = Model::ListReportsRequest>
  Model::ListReportsOutcomeCallable ListReportsCallable(const ListReportsRequestT& request = {}) const {
    return SubmitCallable(&Resiliencehubv2Client::ListReports, request);
  }
 
  template <typename ListReportsRequestT = Model::ListReportsRequest>
  void ListReportsAsync(const ListReportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListReportsRequestT& request = {}) const {
    return SubmitAsync(&Resiliencehubv2Client::ListReports, request, handler, context);
  }
 
  virtual Model::ListResolvedTestRunTargetResourcesOutcome ListResolvedTestRunTargetResources(
      const Model::ListResolvedTestRunTargetResourcesRequest& request) const;
 
  template <typename ListResolvedTestRunTargetResourcesRequestT = Model::ListResolvedTestRunTargetResourcesRequest>
  Model::ListResolvedTestRunTargetResourcesOutcomeCallable ListResolvedTestRunTargetResourcesCallable(
      const ListResolvedTestRunTargetResourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListResolvedTestRunTargetResources, request);
  }
 
  template <typename ListResolvedTestRunTargetResourcesRequestT = Model::ListResolvedTestRunTargetResourcesRequest>
  void ListResolvedTestRunTargetResourcesAsync(const ListResolvedTestRunTargetResourcesRequestT& request,
                                               const ListResolvedTestRunTargetResourcesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListResolvedTestRunTargetResources, request, handler, context);
  }
 
  virtual Model::ListResourcesOutcome ListResources(const Model::ListResourcesRequest& request) const;
 
  template <typename ListResourcesRequestT = Model::ListResourcesRequest>
  Model::ListResourcesOutcomeCallable ListResourcesCallable(const ListResourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListResources, request);
  }
 
  template <typename ListResourcesRequestT = Model::ListResourcesRequest>
  void ListResourcesAsync(const ListResourcesRequestT& request, const ListResourcesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListResources, request, handler, context);
  }
 
  virtual Model::ListServiceEventsOutcome ListServiceEvents(const Model::ListServiceEventsRequest& request) const;
 
  template <typename ListServiceEventsRequestT = Model::ListServiceEventsRequest>
  Model::ListServiceEventsOutcomeCallable ListServiceEventsCallable(const ListServiceEventsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListServiceEvents, request);
  }
 
  template <typename ListServiceEventsRequestT = Model::ListServiceEventsRequest>
  void ListServiceEventsAsync(const ListServiceEventsRequestT& request, const ListServiceEventsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListServiceEvents, request, handler, context);
  }
 
  virtual Model::ListServiceFunctionsOutcome ListServiceFunctions(const Model::ListServiceFunctionsRequest& request) const;
 
  template <typename ListServiceFunctionsRequestT = Model::ListServiceFunctionsRequest>
  Model::ListServiceFunctionsOutcomeCallable ListServiceFunctionsCallable(const ListServiceFunctionsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListServiceFunctions, request);
  }
 
  template <typename ListServiceFunctionsRequestT = Model::ListServiceFunctionsRequest>
  void ListServiceFunctionsAsync(const ListServiceFunctionsRequestT& request, const ListServiceFunctionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListServiceFunctions, request, handler, context);
  }
 
  virtual Model::ListServiceTopologyEdgesOutcome ListServiceTopologyEdges(const Model::ListServiceTopologyEdgesRequest& request) const;
 
  template <typename ListServiceTopologyEdgesRequestT = Model::ListServiceTopologyEdgesRequest>
  Model::ListServiceTopologyEdgesOutcomeCallable ListServiceTopologyEdgesCallable(const ListServiceTopologyEdgesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListServiceTopologyEdges, request);
  }
 
  template <typename ListServiceTopologyEdgesRequestT = Model::ListServiceTopologyEdgesRequest>
  void ListServiceTopologyEdgesAsync(const ListServiceTopologyEdgesRequestT& request,
                                     const ListServiceTopologyEdgesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListServiceTopologyEdges, request, handler, context);
  }
 
  virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
  template <typename ListServicesRequestT = Model::ListServicesRequest>
  Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const {
    return SubmitCallable(&Resiliencehubv2Client::ListServices, request);
  }
 
  template <typename ListServicesRequestT = Model::ListServicesRequest>
  void ListServicesAsync(const ListServicesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListServicesRequestT& request = {}) const {
    return SubmitAsync(&Resiliencehubv2Client::ListServices, request, handler, context);
  }
 
  virtual Model::ListSystemEventsOutcome ListSystemEvents(const Model::ListSystemEventsRequest& request) const;
 
  template <typename ListSystemEventsRequestT = Model::ListSystemEventsRequest>
  Model::ListSystemEventsOutcomeCallable ListSystemEventsCallable(const ListSystemEventsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListSystemEvents, request);
  }
 
  template <typename ListSystemEventsRequestT = Model::ListSystemEventsRequest>
  void ListSystemEventsAsync(const ListSystemEventsRequestT& request, const ListSystemEventsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListSystemEvents, request, handler, context);
  }
 
  virtual Model::ListSystemsOutcome ListSystems(const Model::ListSystemsRequest& request = {}) const;
 
  template <typename ListSystemsRequestT = Model::ListSystemsRequest>
  Model::ListSystemsOutcomeCallable ListSystemsCallable(const ListSystemsRequestT& request = {}) const {
    return SubmitCallable(&Resiliencehubv2Client::ListSystems, request);
  }
 
  template <typename ListSystemsRequestT = Model::ListSystemsRequest>
  void ListSystemsAsync(const ListSystemsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListSystemsRequestT& request = {}) const {
    return SubmitAsync(&Resiliencehubv2Client::ListSystems, 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(&Resiliencehubv2Client::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(&Resiliencehubv2Client::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTestRunEventsOutcome ListTestRunEvents(const Model::ListTestRunEventsRequest& request) const;
 
  template <typename ListTestRunEventsRequestT = Model::ListTestRunEventsRequest>
  Model::ListTestRunEventsOutcomeCallable ListTestRunEventsCallable(const ListTestRunEventsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListTestRunEvents, request);
  }
 
  template <typename ListTestRunEventsRequestT = Model::ListTestRunEventsRequest>
  void ListTestRunEventsAsync(const ListTestRunEventsRequestT& request, const ListTestRunEventsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListTestRunEvents, request, handler, context);
  }
 
  virtual Model::ListTestRunSourcesOutcome ListTestRunSources(const Model::ListTestRunSourcesRequest& request) const;
 
  template <typename ListTestRunSourcesRequestT = Model::ListTestRunSourcesRequest>
  Model::ListTestRunSourcesOutcomeCallable ListTestRunSourcesCallable(const ListTestRunSourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListTestRunSources, request);
  }
 
  template <typename ListTestRunSourcesRequestT = Model::ListTestRunSourcesRequest>
  void ListTestRunSourcesAsync(const ListTestRunSourcesRequestT& request, const ListTestRunSourcesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListTestRunSources, request, handler, context);
  }
 
  virtual Model::ListTestRunsOutcome ListTestRuns(const Model::ListTestRunsRequest& request) const;
 
  template <typename ListTestRunsRequestT = Model::ListTestRunsRequest>
  Model::ListTestRunsOutcomeCallable ListTestRunsCallable(const ListTestRunsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListTestRuns, request);
  }
 
  template <typename ListTestRunsRequestT = Model::ListTestRunsRequest>
  void ListTestRunsAsync(const ListTestRunsRequestT& request, const ListTestRunsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListTestRuns, request, handler, context);
  }
 
  virtual Model::ListTestSourcesOutcome ListTestSources(const Model::ListTestSourcesRequest& request) const;
 
  template <typename ListTestSourcesRequestT = Model::ListTestSourcesRequest>
  Model::ListTestSourcesOutcomeCallable ListTestSourcesCallable(const ListTestSourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListTestSources, request);
  }
 
  template <typename ListTestSourcesRequestT = Model::ListTestSourcesRequest>
  void ListTestSourcesAsync(const ListTestSourcesRequestT& request, const ListTestSourcesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListTestSources, request, handler, context);
  }
 
  virtual Model::ListTestTemplatesOutcome ListTestTemplates(const Model::ListTestTemplatesRequest& request = {}) const;
 
  template <typename ListTestTemplatesRequestT = Model::ListTestTemplatesRequest>
  Model::ListTestTemplatesOutcomeCallable ListTestTemplatesCallable(const ListTestTemplatesRequestT& request = {}) const {
    return SubmitCallable(&Resiliencehubv2Client::ListTestTemplates, request);
  }
 
  template <typename ListTestTemplatesRequestT = Model::ListTestTemplatesRequest>
  void ListTestTemplatesAsync(const ListTestTemplatesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTestTemplatesRequestT& request = {}) const {
    return SubmitAsync(&Resiliencehubv2Client::ListTestTemplates, request, handler, context);
  }
 
  virtual Model::ListTestsOutcome ListTests(const Model::ListTestsRequest& request) const;
 
  template <typename ListTestsRequestT = Model::ListTestsRequest>
  Model::ListTestsOutcomeCallable ListTestsCallable(const ListTestsRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListTests, request);
  }
 
  template <typename ListTestsRequestT = Model::ListTestsRequest>
  void ListTestsAsync(const ListTestsRequestT& request, const ListTestsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListTests, request, handler, context);
  }
 
  virtual Model::ListUserJourneysOutcome ListUserJourneys(const Model::ListUserJourneysRequest& request) const;
 
  template <typename ListUserJourneysRequestT = Model::ListUserJourneysRequest>
  Model::ListUserJourneysOutcomeCallable ListUserJourneysCallable(const ListUserJourneysRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::ListUserJourneys, request);
  }
 
  template <typename ListUserJourneysRequestT = Model::ListUserJourneysRequest>
  void ListUserJourneysAsync(const ListUserJourneysRequestT& request, const ListUserJourneysResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::ListUserJourneys, request, handler, context);
  }
 
  virtual Model::PutTestSourcesOutcome PutTestSources(const Model::PutTestSourcesRequest& request) const;
 
  template <typename PutTestSourcesRequestT = Model::PutTestSourcesRequest>
  Model::PutTestSourcesOutcomeCallable PutTestSourcesCallable(const PutTestSourcesRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::PutTestSources, request);
  }
 
  template <typename PutTestSourcesRequestT = Model::PutTestSourcesRequest>
  void PutTestSourcesAsync(const PutTestSourcesRequestT& request, const PutTestSourcesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::PutTestSources, request, handler, context);
  }
 
  virtual Model::StartFailureModeAssessmentOutcome StartFailureModeAssessment(
      const Model::StartFailureModeAssessmentRequest& request) const;
 
  template <typename StartFailureModeAssessmentRequestT = Model::StartFailureModeAssessmentRequest>
  Model::StartFailureModeAssessmentOutcomeCallable StartFailureModeAssessmentCallable(
      const StartFailureModeAssessmentRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::StartFailureModeAssessment, request);
  }
 
  template <typename StartFailureModeAssessmentRequestT = Model::StartFailureModeAssessmentRequest>
  void StartFailureModeAssessmentAsync(const StartFailureModeAssessmentRequestT& request,
                                       const StartFailureModeAssessmentResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::StartFailureModeAssessment, request, handler, context);
  }
 
  virtual Model::StartTestRunOutcome StartTestRun(const Model::StartTestRunRequest& request) const;
 
  template <typename StartTestRunRequestT = Model::StartTestRunRequest>
  Model::StartTestRunOutcomeCallable StartTestRunCallable(const StartTestRunRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::StartTestRun, request);
  }
 
  template <typename StartTestRunRequestT = Model::StartTestRunRequest>
  void StartTestRunAsync(const StartTestRunRequestT& request, const StartTestRunResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::StartTestRun, request, handler, context);
  }
 
  virtual Model::StopTestRunOutcome StopTestRun(const Model::StopTestRunRequest& request) const;
 
  template <typename StopTestRunRequestT = Model::StopTestRunRequest>
  Model::StopTestRunOutcomeCallable StopTestRunCallable(const StopTestRunRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::StopTestRun, request);
  }
 
  template <typename StopTestRunRequestT = Model::StopTestRunRequest>
  void StopTestRunAsync(const StopTestRunRequestT& request, const StopTestRunResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::StopTestRun, 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(&Resiliencehubv2Client::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(&Resiliencehubv2Client::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(&Resiliencehubv2Client::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(&Resiliencehubv2Client::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAssertionOutcome UpdateAssertion(const Model::UpdateAssertionRequest& request) const;
 
  template <typename UpdateAssertionRequestT = Model::UpdateAssertionRequest>
  Model::UpdateAssertionOutcomeCallable UpdateAssertionCallable(const UpdateAssertionRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateAssertion, request);
  }
 
  template <typename UpdateAssertionRequestT = Model::UpdateAssertionRequest>
  void UpdateAssertionAsync(const UpdateAssertionRequestT& request, const UpdateAssertionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateAssertion, request, handler, context);
  }
 
  virtual Model::UpdateDependencyOutcome UpdateDependency(const Model::UpdateDependencyRequest& request) const;
 
  template <typename UpdateDependencyRequestT = Model::UpdateDependencyRequest>
  Model::UpdateDependencyOutcomeCallable UpdateDependencyCallable(const UpdateDependencyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateDependency, request);
  }
 
  template <typename UpdateDependencyRequestT = Model::UpdateDependencyRequest>
  void UpdateDependencyAsync(const UpdateDependencyRequestT& request, const UpdateDependencyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateDependency, request, handler, context);
  }
 
  virtual Model::UpdateFailureModeFindingOutcome UpdateFailureModeFinding(const Model::UpdateFailureModeFindingRequest& request) const;
 
  template <typename UpdateFailureModeFindingRequestT = Model::UpdateFailureModeFindingRequest>
  Model::UpdateFailureModeFindingOutcomeCallable UpdateFailureModeFindingCallable(const UpdateFailureModeFindingRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateFailureModeFinding, request);
  }
 
  template <typename UpdateFailureModeFindingRequestT = Model::UpdateFailureModeFindingRequest>
  void UpdateFailureModeFindingAsync(const UpdateFailureModeFindingRequestT& request,
                                     const UpdateFailureModeFindingResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateFailureModeFinding, request, handler, context);
  }
 
  virtual Model::UpdatePolicyOutcome UpdatePolicy(const Model::UpdatePolicyRequest& request) const;
 
  template <typename UpdatePolicyRequestT = Model::UpdatePolicyRequest>
  Model::UpdatePolicyOutcomeCallable UpdatePolicyCallable(const UpdatePolicyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdatePolicy, request);
  }
 
  template <typename UpdatePolicyRequestT = Model::UpdatePolicyRequest>
  void UpdatePolicyAsync(const UpdatePolicyRequestT& request, const UpdatePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdatePolicy, request, handler, context);
  }
 
  virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const;
 
  template <typename UpdateServiceRequestT = Model::UpdateServiceRequest>
  Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const UpdateServiceRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateService, request);
  }
 
  template <typename UpdateServiceRequestT = Model::UpdateServiceRequest>
  void UpdateServiceAsync(const UpdateServiceRequestT& request, const UpdateServiceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateService, request, handler, context);
  }
 
  virtual Model::UpdateServiceFunctionOutcome UpdateServiceFunction(const Model::UpdateServiceFunctionRequest& request) const;
 
  template <typename UpdateServiceFunctionRequestT = Model::UpdateServiceFunctionRequest>
  Model::UpdateServiceFunctionOutcomeCallable UpdateServiceFunctionCallable(const UpdateServiceFunctionRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateServiceFunction, request);
  }
 
  template <typename UpdateServiceFunctionRequestT = Model::UpdateServiceFunctionRequest>
  void UpdateServiceFunctionAsync(const UpdateServiceFunctionRequestT& request, const UpdateServiceFunctionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateServiceFunction, request, handler, context);
  }
 
  virtual Model::UpdateSystemOutcome UpdateSystem(const Model::UpdateSystemRequest& request) const;
 
  template <typename UpdateSystemRequestT = Model::UpdateSystemRequest>
  Model::UpdateSystemOutcomeCallable UpdateSystemCallable(const UpdateSystemRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateSystem, request);
  }
 
  template <typename UpdateSystemRequestT = Model::UpdateSystemRequest>
  void UpdateSystemAsync(const UpdateSystemRequestT& request, const UpdateSystemResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateSystem, request, handler, context);
  }
 
  virtual Model::UpdateTestOutcome UpdateTest(const Model::UpdateTestRequest& request) const;
 
  template <typename UpdateTestRequestT = Model::UpdateTestRequest>
  Model::UpdateTestOutcomeCallable UpdateTestCallable(const UpdateTestRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateTest, request);
  }
 
  template <typename UpdateTestRequestT = Model::UpdateTestRequest>
  void UpdateTestAsync(const UpdateTestRequestT& request, const UpdateTestResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateTest, request, handler, context);
  }
 
  virtual Model::UpdateUserJourneyOutcome UpdateUserJourney(const Model::UpdateUserJourneyRequest& request) const;
 
  template <typename UpdateUserJourneyRequestT = Model::UpdateUserJourneyRequest>
  Model::UpdateUserJourneyOutcomeCallable UpdateUserJourneyCallable(const UpdateUserJourneyRequestT& request) const {
    return SubmitCallable(&Resiliencehubv2Client::UpdateUserJourney, request);
  }
 
  template <typename UpdateUserJourneyRequestT = Model::UpdateUserJourneyRequest>
  void UpdateUserJourneyAsync(const UpdateUserJourneyRequestT& request, const UpdateUserJourneyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Resiliencehubv2Client::UpdateUserJourney, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Resiliencehubv2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Resiliencehubv2Client>;
  void init(const Resiliencehubv2ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Resiliencehubv2Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  Resiliencehubv2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<Resiliencehubv2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace resiliencehubv2
}  // namespace Aws