FISClient.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/fis/FISPaginationBase.h>
#include <aws/fis/FISServiceClientModel.h>
#include <aws/fis/FIS_EXPORTS.h>
 
namespace Aws {
namespace FIS {
class AWS_FIS_API FISClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<FISClient>,
                              public FISPaginationBase<FISClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef FISClientConfiguration ClientConfigurationType;
  typedef FISEndpointProvider EndpointProviderType;
 
  FISClient(const Aws::FIS::FISClientConfiguration& clientConfiguration = Aws::FIS::FISClientConfiguration(),
            std::shared_ptr<FISEndpointProviderBase> endpointProvider = nullptr);
 
  FISClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<FISEndpointProviderBase> endpointProvider = nullptr,
            const Aws::FIS::FISClientConfiguration& clientConfiguration = Aws::FIS::FISClientConfiguration());
 
  FISClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<FISEndpointProviderBase> endpointProvider = nullptr,
            const Aws::FIS::FISClientConfiguration& clientConfiguration = Aws::FIS::FISClientConfiguration());
 
  /* Legacy constructors due deprecation */
  FISClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  FISClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  FISClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~FISClient();
 
  virtual Model::CreateExperimentTemplateOutcome CreateExperimentTemplate(const Model::CreateExperimentTemplateRequest& request) const;
 
  template <typename CreateExperimentTemplateRequestT = Model::CreateExperimentTemplateRequest>
  Model::CreateExperimentTemplateOutcomeCallable CreateExperimentTemplateCallable(const CreateExperimentTemplateRequestT& request) const {
    return SubmitCallable(&FISClient::CreateExperimentTemplate, request);
  }
 
  template <typename CreateExperimentTemplateRequestT = Model::CreateExperimentTemplateRequest>
  void CreateExperimentTemplateAsync(const CreateExperimentTemplateRequestT& request,
                                     const CreateExperimentTemplateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::CreateExperimentTemplate, request, handler, context);
  }
 
  virtual Model::CreateTargetAccountConfigurationOutcome CreateTargetAccountConfiguration(
      const Model::CreateTargetAccountConfigurationRequest& request) const;
 
  template <typename CreateTargetAccountConfigurationRequestT = Model::CreateTargetAccountConfigurationRequest>
  Model::CreateTargetAccountConfigurationOutcomeCallable CreateTargetAccountConfigurationCallable(
      const CreateTargetAccountConfigurationRequestT& request) const {
    return SubmitCallable(&FISClient::CreateTargetAccountConfiguration, request);
  }
 
  template <typename CreateTargetAccountConfigurationRequestT = Model::CreateTargetAccountConfigurationRequest>
  void CreateTargetAccountConfigurationAsync(const CreateTargetAccountConfigurationRequestT& request,
                                             const CreateTargetAccountConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::CreateTargetAccountConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteExperimentTemplateOutcome DeleteExperimentTemplate(const Model::DeleteExperimentTemplateRequest& request) const;
 
  template <typename DeleteExperimentTemplateRequestT = Model::DeleteExperimentTemplateRequest>
  Model::DeleteExperimentTemplateOutcomeCallable DeleteExperimentTemplateCallable(const DeleteExperimentTemplateRequestT& request) const {
    return SubmitCallable(&FISClient::DeleteExperimentTemplate, request);
  }
 
  template <typename DeleteExperimentTemplateRequestT = Model::DeleteExperimentTemplateRequest>
  void DeleteExperimentTemplateAsync(const DeleteExperimentTemplateRequestT& request,
                                     const DeleteExperimentTemplateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::DeleteExperimentTemplate, request, handler, context);
  }
 
  virtual Model::DeleteTargetAccountConfigurationOutcome DeleteTargetAccountConfiguration(
      const Model::DeleteTargetAccountConfigurationRequest& request) const;
 
  template <typename DeleteTargetAccountConfigurationRequestT = Model::DeleteTargetAccountConfigurationRequest>
  Model::DeleteTargetAccountConfigurationOutcomeCallable DeleteTargetAccountConfigurationCallable(
      const DeleteTargetAccountConfigurationRequestT& request) const {
    return SubmitCallable(&FISClient::DeleteTargetAccountConfiguration, request);
  }
 
  template <typename DeleteTargetAccountConfigurationRequestT = Model::DeleteTargetAccountConfigurationRequest>
  void DeleteTargetAccountConfigurationAsync(const DeleteTargetAccountConfigurationRequestT& request,
                                             const DeleteTargetAccountConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::DeleteTargetAccountConfiguration, request, handler, context);
  }
 
  virtual Model::GetActionOutcome GetAction(const Model::GetActionRequest& request) const;
 
  template <typename GetActionRequestT = Model::GetActionRequest>
  Model::GetActionOutcomeCallable GetActionCallable(const GetActionRequestT& request) const {
    return SubmitCallable(&FISClient::GetAction, request);
  }
 
  template <typename GetActionRequestT = Model::GetActionRequest>
  void GetActionAsync(const GetActionRequestT& request, const GetActionResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetAction, request, handler, context);
  }
 
  virtual Model::GetExperimentOutcome GetExperiment(const Model::GetExperimentRequest& request) const;
 
  template <typename GetExperimentRequestT = Model::GetExperimentRequest>
  Model::GetExperimentOutcomeCallable GetExperimentCallable(const GetExperimentRequestT& request) const {
    return SubmitCallable(&FISClient::GetExperiment, request);
  }
 
  template <typename GetExperimentRequestT = Model::GetExperimentRequest>
  void GetExperimentAsync(const GetExperimentRequestT& request, const GetExperimentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetExperiment, request, handler, context);
  }
 
  virtual Model::GetExperimentTargetAccountConfigurationOutcome GetExperimentTargetAccountConfiguration(
      const Model::GetExperimentTargetAccountConfigurationRequest& request) const;
 
  template <typename GetExperimentTargetAccountConfigurationRequestT = Model::GetExperimentTargetAccountConfigurationRequest>
  Model::GetExperimentTargetAccountConfigurationOutcomeCallable GetExperimentTargetAccountConfigurationCallable(
      const GetExperimentTargetAccountConfigurationRequestT& request) const {
    return SubmitCallable(&FISClient::GetExperimentTargetAccountConfiguration, request);
  }
 
  template <typename GetExperimentTargetAccountConfigurationRequestT = Model::GetExperimentTargetAccountConfigurationRequest>
  void GetExperimentTargetAccountConfigurationAsync(const GetExperimentTargetAccountConfigurationRequestT& request,
                                                    const GetExperimentTargetAccountConfigurationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetExperimentTargetAccountConfiguration, request, handler, context);
  }
 
  virtual Model::GetExperimentTemplateOutcome GetExperimentTemplate(const Model::GetExperimentTemplateRequest& request) const;
 
  template <typename GetExperimentTemplateRequestT = Model::GetExperimentTemplateRequest>
  Model::GetExperimentTemplateOutcomeCallable GetExperimentTemplateCallable(const GetExperimentTemplateRequestT& request) const {
    return SubmitCallable(&FISClient::GetExperimentTemplate, request);
  }
 
  template <typename GetExperimentTemplateRequestT = Model::GetExperimentTemplateRequest>
  void GetExperimentTemplateAsync(const GetExperimentTemplateRequestT& request, const GetExperimentTemplateResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetExperimentTemplate, request, handler, context);
  }
 
  virtual Model::GetSafetyLeverOutcome GetSafetyLever(const Model::GetSafetyLeverRequest& request) const;
 
  template <typename GetSafetyLeverRequestT = Model::GetSafetyLeverRequest>
  Model::GetSafetyLeverOutcomeCallable GetSafetyLeverCallable(const GetSafetyLeverRequestT& request) const {
    return SubmitCallable(&FISClient::GetSafetyLever, request);
  }
 
  template <typename GetSafetyLeverRequestT = Model::GetSafetyLeverRequest>
  void GetSafetyLeverAsync(const GetSafetyLeverRequestT& request, const GetSafetyLeverResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetSafetyLever, request, handler, context);
  }
 
  virtual Model::GetTargetAccountConfigurationOutcome GetTargetAccountConfiguration(
      const Model::GetTargetAccountConfigurationRequest& request) const;
 
  template <typename GetTargetAccountConfigurationRequestT = Model::GetTargetAccountConfigurationRequest>
  Model::GetTargetAccountConfigurationOutcomeCallable GetTargetAccountConfigurationCallable(
      const GetTargetAccountConfigurationRequestT& request) const {
    return SubmitCallable(&FISClient::GetTargetAccountConfiguration, request);
  }
 
  template <typename GetTargetAccountConfigurationRequestT = Model::GetTargetAccountConfigurationRequest>
  void GetTargetAccountConfigurationAsync(const GetTargetAccountConfigurationRequestT& request,
                                          const GetTargetAccountConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetTargetAccountConfiguration, request, handler, context);
  }
 
  virtual Model::GetTargetResourceTypeOutcome GetTargetResourceType(const Model::GetTargetResourceTypeRequest& request) const;
 
  template <typename GetTargetResourceTypeRequestT = Model::GetTargetResourceTypeRequest>
  Model::GetTargetResourceTypeOutcomeCallable GetTargetResourceTypeCallable(const GetTargetResourceTypeRequestT& request) const {
    return SubmitCallable(&FISClient::GetTargetResourceType, request);
  }
 
  template <typename GetTargetResourceTypeRequestT = Model::GetTargetResourceTypeRequest>
  void GetTargetResourceTypeAsync(const GetTargetResourceTypeRequestT& request, const GetTargetResourceTypeResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::GetTargetResourceType, request, handler, context);
  }
 
  virtual Model::ListActionsOutcome ListActions(const Model::ListActionsRequest& request = {}) const;
 
  template <typename ListActionsRequestT = Model::ListActionsRequest>
  Model::ListActionsOutcomeCallable ListActionsCallable(const ListActionsRequestT& request = {}) const {
    return SubmitCallable(&FISClient::ListActions, request);
  }
 
  template <typename ListActionsRequestT = Model::ListActionsRequest>
  void ListActionsAsync(const ListActionsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListActionsRequestT& request = {}) const {
    return SubmitAsync(&FISClient::ListActions, request, handler, context);
  }
 
  virtual Model::ListExperimentResolvedTargetsOutcome ListExperimentResolvedTargets(
      const Model::ListExperimentResolvedTargetsRequest& request) const;
 
  template <typename ListExperimentResolvedTargetsRequestT = Model::ListExperimentResolvedTargetsRequest>
  Model::ListExperimentResolvedTargetsOutcomeCallable ListExperimentResolvedTargetsCallable(
      const ListExperimentResolvedTargetsRequestT& request) const {
    return SubmitCallable(&FISClient::ListExperimentResolvedTargets, request);
  }
 
  template <typename ListExperimentResolvedTargetsRequestT = Model::ListExperimentResolvedTargetsRequest>
  void ListExperimentResolvedTargetsAsync(const ListExperimentResolvedTargetsRequestT& request,
                                          const ListExperimentResolvedTargetsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::ListExperimentResolvedTargets, request, handler, context);
  }
 
  virtual Model::ListExperimentTargetAccountConfigurationsOutcome ListExperimentTargetAccountConfigurations(
      const Model::ListExperimentTargetAccountConfigurationsRequest& request) const;
 
  template <typename ListExperimentTargetAccountConfigurationsRequestT = Model::ListExperimentTargetAccountConfigurationsRequest>
  Model::ListExperimentTargetAccountConfigurationsOutcomeCallable ListExperimentTargetAccountConfigurationsCallable(
      const ListExperimentTargetAccountConfigurationsRequestT& request) const {
    return SubmitCallable(&FISClient::ListExperimentTargetAccountConfigurations, request);
  }
 
  template <typename ListExperimentTargetAccountConfigurationsRequestT = Model::ListExperimentTargetAccountConfigurationsRequest>
  void ListExperimentTargetAccountConfigurationsAsync(
      const ListExperimentTargetAccountConfigurationsRequestT& request,
      const ListExperimentTargetAccountConfigurationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::ListExperimentTargetAccountConfigurations, request, handler, context);
  }
 
  virtual Model::ListExperimentTemplatesOutcome ListExperimentTemplates(const Model::ListExperimentTemplatesRequest& request = {}) const;
 
  template <typename ListExperimentTemplatesRequestT = Model::ListExperimentTemplatesRequest>
  Model::ListExperimentTemplatesOutcomeCallable ListExperimentTemplatesCallable(const ListExperimentTemplatesRequestT& request = {}) const {
    return SubmitCallable(&FISClient::ListExperimentTemplates, request);
  }
 
  template <typename ListExperimentTemplatesRequestT = Model::ListExperimentTemplatesRequest>
  void ListExperimentTemplatesAsync(const ListExperimentTemplatesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListExperimentTemplatesRequestT& request = {}) const {
    return SubmitAsync(&FISClient::ListExperimentTemplates, request, handler, context);
  }
 
  virtual Model::ListExperimentsOutcome ListExperiments(const Model::ListExperimentsRequest& request = {}) const;
 
  template <typename ListExperimentsRequestT = Model::ListExperimentsRequest>
  Model::ListExperimentsOutcomeCallable ListExperimentsCallable(const ListExperimentsRequestT& request = {}) const {
    return SubmitCallable(&FISClient::ListExperiments, request);
  }
 
  template <typename ListExperimentsRequestT = Model::ListExperimentsRequest>
  void ListExperimentsAsync(const ListExperimentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListExperimentsRequestT& request = {}) const {
    return SubmitAsync(&FISClient::ListExperiments, 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(&FISClient::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(&FISClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTargetAccountConfigurationsOutcome ListTargetAccountConfigurations(
      const Model::ListTargetAccountConfigurationsRequest& request) const;
 
  template <typename ListTargetAccountConfigurationsRequestT = Model::ListTargetAccountConfigurationsRequest>
  Model::ListTargetAccountConfigurationsOutcomeCallable ListTargetAccountConfigurationsCallable(
      const ListTargetAccountConfigurationsRequestT& request) const {
    return SubmitCallable(&FISClient::ListTargetAccountConfigurations, request);
  }
 
  template <typename ListTargetAccountConfigurationsRequestT = Model::ListTargetAccountConfigurationsRequest>
  void ListTargetAccountConfigurationsAsync(const ListTargetAccountConfigurationsRequestT& request,
                                            const ListTargetAccountConfigurationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::ListTargetAccountConfigurations, request, handler, context);
  }
 
  virtual Model::ListTargetResourceTypesOutcome ListTargetResourceTypes(const Model::ListTargetResourceTypesRequest& request = {}) const;
 
  template <typename ListTargetResourceTypesRequestT = Model::ListTargetResourceTypesRequest>
  Model::ListTargetResourceTypesOutcomeCallable ListTargetResourceTypesCallable(const ListTargetResourceTypesRequestT& request = {}) const {
    return SubmitCallable(&FISClient::ListTargetResourceTypes, request);
  }
 
  template <typename ListTargetResourceTypesRequestT = Model::ListTargetResourceTypesRequest>
  void ListTargetResourceTypesAsync(const ListTargetResourceTypesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListTargetResourceTypesRequestT& request = {}) const {
    return SubmitAsync(&FISClient::ListTargetResourceTypes, request, handler, context);
  }
 
  virtual Model::StartExperimentOutcome StartExperiment(const Model::StartExperimentRequest& request) const;
 
  template <typename StartExperimentRequestT = Model::StartExperimentRequest>
  Model::StartExperimentOutcomeCallable StartExperimentCallable(const StartExperimentRequestT& request) const {
    return SubmitCallable(&FISClient::StartExperiment, request);
  }
 
  template <typename StartExperimentRequestT = Model::StartExperimentRequest>
  void StartExperimentAsync(const StartExperimentRequestT& request, const StartExperimentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::StartExperiment, request, handler, context);
  }
 
  virtual Model::StopExperimentOutcome StopExperiment(const Model::StopExperimentRequest& request) const;
 
  template <typename StopExperimentRequestT = Model::StopExperimentRequest>
  Model::StopExperimentOutcomeCallable StopExperimentCallable(const StopExperimentRequestT& request) const {
    return SubmitCallable(&FISClient::StopExperiment, request);
  }
 
  template <typename StopExperimentRequestT = Model::StopExperimentRequest>
  void StopExperimentAsync(const StopExperimentRequestT& request, const StopExperimentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::StopExperiment, 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(&FISClient::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(&FISClient::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(&FISClient::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(&FISClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateExperimentTemplateOutcome UpdateExperimentTemplate(const Model::UpdateExperimentTemplateRequest& request) const;
 
  template <typename UpdateExperimentTemplateRequestT = Model::UpdateExperimentTemplateRequest>
  Model::UpdateExperimentTemplateOutcomeCallable UpdateExperimentTemplateCallable(const UpdateExperimentTemplateRequestT& request) const {
    return SubmitCallable(&FISClient::UpdateExperimentTemplate, request);
  }
 
  template <typename UpdateExperimentTemplateRequestT = Model::UpdateExperimentTemplateRequest>
  void UpdateExperimentTemplateAsync(const UpdateExperimentTemplateRequestT& request,
                                     const UpdateExperimentTemplateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::UpdateExperimentTemplate, request, handler, context);
  }
 
  virtual Model::UpdateSafetyLeverStateOutcome UpdateSafetyLeverState(const Model::UpdateSafetyLeverStateRequest& request) const;
 
  template <typename UpdateSafetyLeverStateRequestT = Model::UpdateSafetyLeverStateRequest>
  Model::UpdateSafetyLeverStateOutcomeCallable UpdateSafetyLeverStateCallable(const UpdateSafetyLeverStateRequestT& request) const {
    return SubmitCallable(&FISClient::UpdateSafetyLeverState, request);
  }
 
  template <typename UpdateSafetyLeverStateRequestT = Model::UpdateSafetyLeverStateRequest>
  void UpdateSafetyLeverStateAsync(const UpdateSafetyLeverStateRequestT& request,
                                   const UpdateSafetyLeverStateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::UpdateSafetyLeverState, request, handler, context);
  }
 
  virtual Model::UpdateTargetAccountConfigurationOutcome UpdateTargetAccountConfiguration(
      const Model::UpdateTargetAccountConfigurationRequest& request) const;
 
  template <typename UpdateTargetAccountConfigurationRequestT = Model::UpdateTargetAccountConfigurationRequest>
  Model::UpdateTargetAccountConfigurationOutcomeCallable UpdateTargetAccountConfigurationCallable(
      const UpdateTargetAccountConfigurationRequestT& request) const {
    return SubmitCallable(&FISClient::UpdateTargetAccountConfiguration, request);
  }
 
  template <typename UpdateTargetAccountConfigurationRequestT = Model::UpdateTargetAccountConfigurationRequest>
  void UpdateTargetAccountConfigurationAsync(const UpdateTargetAccountConfigurationRequestT& request,
                                             const UpdateTargetAccountConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FISClient::UpdateTargetAccountConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<FISEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<FISClient>;
  void init(const FISClientConfiguration& clientConfiguration);
 
  FISClientConfiguration m_clientConfiguration;
  std::shared_ptr<FISEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace FIS
}  // namespace Aws