FISClient.h

 
#pragma once
#include <aws/fis/FIS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/fis/FISServiceClientModel.h>
 
namespace Aws
{
namespace FIS
{
  class AWS_FIS_API FISClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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