SFNClient.h

 
#pragma once
#include <aws/states/SFN_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/states/SFNServiceClientModel.h>
 
namespace Aws
{
namespace SFN
{
  class AWS_SFN_API SFNClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SFNClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SFNClientConfiguration ClientConfigurationType;
      typedef SFNEndpointProvider EndpointProviderType;
 
        SFNClient(const Aws::SFN::SFNClientConfiguration& clientConfiguration = Aws::SFN::SFNClientConfiguration(),
                  std::shared_ptr<SFNEndpointProviderBase> endpointProvider = nullptr);
 
        SFNClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<SFNEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SFN::SFNClientConfiguration& clientConfiguration = Aws::SFN::SFNClientConfiguration());
 
        SFNClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SFNEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SFN::SFNClientConfiguration& clientConfiguration = Aws::SFN::SFNClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SFNClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SFNClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SFNClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SFNClient();
 
        virtual Model::CreateActivityOutcome CreateActivity(const Model::CreateActivityRequest& request) const;
 
        template<typename CreateActivityRequestT = Model::CreateActivityRequest>
        Model::CreateActivityOutcomeCallable CreateActivityCallable(const CreateActivityRequestT& request) const
        {
            return SubmitCallable(&SFNClient::CreateActivity, request);
        }
 
        template<typename CreateActivityRequestT = Model::CreateActivityRequest>
        void CreateActivityAsync(const CreateActivityRequestT& request, const CreateActivityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::CreateActivity, request, handler, context);
        }
 
        virtual Model::CreateStateMachineOutcome CreateStateMachine(const Model::CreateStateMachineRequest& request) const;
 
        template<typename CreateStateMachineRequestT = Model::CreateStateMachineRequest>
        Model::CreateStateMachineOutcomeCallable CreateStateMachineCallable(const CreateStateMachineRequestT& request) const
        {
            return SubmitCallable(&SFNClient::CreateStateMachine, request);
        }
 
        template<typename CreateStateMachineRequestT = Model::CreateStateMachineRequest>
        void CreateStateMachineAsync(const CreateStateMachineRequestT& request, const CreateStateMachineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::CreateStateMachine, request, handler, context);
        }
 
        virtual Model::CreateStateMachineAliasOutcome CreateStateMachineAlias(const Model::CreateStateMachineAliasRequest& request) const;
 
        template<typename CreateStateMachineAliasRequestT = Model::CreateStateMachineAliasRequest>
        Model::CreateStateMachineAliasOutcomeCallable CreateStateMachineAliasCallable(const CreateStateMachineAliasRequestT& request) const
        {
            return SubmitCallable(&SFNClient::CreateStateMachineAlias, request);
        }
 
        template<typename CreateStateMachineAliasRequestT = Model::CreateStateMachineAliasRequest>
        void CreateStateMachineAliasAsync(const CreateStateMachineAliasRequestT& request, const CreateStateMachineAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::CreateStateMachineAlias, request, handler, context);
        }
 
        virtual Model::DeleteActivityOutcome DeleteActivity(const Model::DeleteActivityRequest& request) const;
 
        template<typename DeleteActivityRequestT = Model::DeleteActivityRequest>
        Model::DeleteActivityOutcomeCallable DeleteActivityCallable(const DeleteActivityRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DeleteActivity, request);
        }
 
        template<typename DeleteActivityRequestT = Model::DeleteActivityRequest>
        void DeleteActivityAsync(const DeleteActivityRequestT& request, const DeleteActivityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DeleteActivity, request, handler, context);
        }
 
        virtual Model::DeleteStateMachineOutcome DeleteStateMachine(const Model::DeleteStateMachineRequest& request) const;
 
        template<typename DeleteStateMachineRequestT = Model::DeleteStateMachineRequest>
        Model::DeleteStateMachineOutcomeCallable DeleteStateMachineCallable(const DeleteStateMachineRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DeleteStateMachine, request);
        }
 
        template<typename DeleteStateMachineRequestT = Model::DeleteStateMachineRequest>
        void DeleteStateMachineAsync(const DeleteStateMachineRequestT& request, const DeleteStateMachineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DeleteStateMachine, request, handler, context);
        }
 
        virtual Model::DeleteStateMachineAliasOutcome DeleteStateMachineAlias(const Model::DeleteStateMachineAliasRequest& request) const;
 
        template<typename DeleteStateMachineAliasRequestT = Model::DeleteStateMachineAliasRequest>
        Model::DeleteStateMachineAliasOutcomeCallable DeleteStateMachineAliasCallable(const DeleteStateMachineAliasRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DeleteStateMachineAlias, request);
        }
 
        template<typename DeleteStateMachineAliasRequestT = Model::DeleteStateMachineAliasRequest>
        void DeleteStateMachineAliasAsync(const DeleteStateMachineAliasRequestT& request, const DeleteStateMachineAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DeleteStateMachineAlias, request, handler, context);
        }
 
        virtual Model::DeleteStateMachineVersionOutcome DeleteStateMachineVersion(const Model::DeleteStateMachineVersionRequest& request) const;
 
        template<typename DeleteStateMachineVersionRequestT = Model::DeleteStateMachineVersionRequest>
        Model::DeleteStateMachineVersionOutcomeCallable DeleteStateMachineVersionCallable(const DeleteStateMachineVersionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DeleteStateMachineVersion, request);
        }
 
        template<typename DeleteStateMachineVersionRequestT = Model::DeleteStateMachineVersionRequest>
        void DeleteStateMachineVersionAsync(const DeleteStateMachineVersionRequestT& request, const DeleteStateMachineVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DeleteStateMachineVersion, request, handler, context);
        }
 
        virtual Model::DescribeActivityOutcome DescribeActivity(const Model::DescribeActivityRequest& request) const;
 
        template<typename DescribeActivityRequestT = Model::DescribeActivityRequest>
        Model::DescribeActivityOutcomeCallable DescribeActivityCallable(const DescribeActivityRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DescribeActivity, request);
        }
 
        template<typename DescribeActivityRequestT = Model::DescribeActivityRequest>
        void DescribeActivityAsync(const DescribeActivityRequestT& request, const DescribeActivityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DescribeActivity, request, handler, context);
        }
 
        virtual Model::DescribeExecutionOutcome DescribeExecution(const Model::DescribeExecutionRequest& request) const;
 
        template<typename DescribeExecutionRequestT = Model::DescribeExecutionRequest>
        Model::DescribeExecutionOutcomeCallable DescribeExecutionCallable(const DescribeExecutionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DescribeExecution, request);
        }
 
        template<typename DescribeExecutionRequestT = Model::DescribeExecutionRequest>
        void DescribeExecutionAsync(const DescribeExecutionRequestT& request, const DescribeExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DescribeExecution, request, handler, context);
        }
 
        virtual Model::DescribeMapRunOutcome DescribeMapRun(const Model::DescribeMapRunRequest& request) const;
 
        template<typename DescribeMapRunRequestT = Model::DescribeMapRunRequest>
        Model::DescribeMapRunOutcomeCallable DescribeMapRunCallable(const DescribeMapRunRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DescribeMapRun, request);
        }
 
        template<typename DescribeMapRunRequestT = Model::DescribeMapRunRequest>
        void DescribeMapRunAsync(const DescribeMapRunRequestT& request, const DescribeMapRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DescribeMapRun, request, handler, context);
        }
 
        virtual Model::DescribeStateMachineOutcome DescribeStateMachine(const Model::DescribeStateMachineRequest& request) const;
 
        template<typename DescribeStateMachineRequestT = Model::DescribeStateMachineRequest>
        Model::DescribeStateMachineOutcomeCallable DescribeStateMachineCallable(const DescribeStateMachineRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DescribeStateMachine, request);
        }
 
        template<typename DescribeStateMachineRequestT = Model::DescribeStateMachineRequest>
        void DescribeStateMachineAsync(const DescribeStateMachineRequestT& request, const DescribeStateMachineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DescribeStateMachine, request, handler, context);
        }
 
        virtual Model::DescribeStateMachineAliasOutcome DescribeStateMachineAlias(const Model::DescribeStateMachineAliasRequest& request) const;
 
        template<typename DescribeStateMachineAliasRequestT = Model::DescribeStateMachineAliasRequest>
        Model::DescribeStateMachineAliasOutcomeCallable DescribeStateMachineAliasCallable(const DescribeStateMachineAliasRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DescribeStateMachineAlias, request);
        }
 
        template<typename DescribeStateMachineAliasRequestT = Model::DescribeStateMachineAliasRequest>
        void DescribeStateMachineAliasAsync(const DescribeStateMachineAliasRequestT& request, const DescribeStateMachineAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DescribeStateMachineAlias, request, handler, context);
        }
 
        virtual Model::DescribeStateMachineForExecutionOutcome DescribeStateMachineForExecution(const Model::DescribeStateMachineForExecutionRequest& request) const;
 
        template<typename DescribeStateMachineForExecutionRequestT = Model::DescribeStateMachineForExecutionRequest>
        Model::DescribeStateMachineForExecutionOutcomeCallable DescribeStateMachineForExecutionCallable(const DescribeStateMachineForExecutionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::DescribeStateMachineForExecution, request);
        }
 
        template<typename DescribeStateMachineForExecutionRequestT = Model::DescribeStateMachineForExecutionRequest>
        void DescribeStateMachineForExecutionAsync(const DescribeStateMachineForExecutionRequestT& request, const DescribeStateMachineForExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::DescribeStateMachineForExecution, request, handler, context);
        }
 
        virtual Model::GetActivityTaskOutcome GetActivityTask(const Model::GetActivityTaskRequest& request) const;
 
        template<typename GetActivityTaskRequestT = Model::GetActivityTaskRequest>
        Model::GetActivityTaskOutcomeCallable GetActivityTaskCallable(const GetActivityTaskRequestT& request) const
        {
            return SubmitCallable(&SFNClient::GetActivityTask, request);
        }
 
        template<typename GetActivityTaskRequestT = Model::GetActivityTaskRequest>
        void GetActivityTaskAsync(const GetActivityTaskRequestT& request, const GetActivityTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::GetActivityTask, request, handler, context);
        }
 
        virtual Model::GetExecutionHistoryOutcome GetExecutionHistory(const Model::GetExecutionHistoryRequest& request) const;
 
        template<typename GetExecutionHistoryRequestT = Model::GetExecutionHistoryRequest>
        Model::GetExecutionHistoryOutcomeCallable GetExecutionHistoryCallable(const GetExecutionHistoryRequestT& request) const
        {
            return SubmitCallable(&SFNClient::GetExecutionHistory, request);
        }
 
        template<typename GetExecutionHistoryRequestT = Model::GetExecutionHistoryRequest>
        void GetExecutionHistoryAsync(const GetExecutionHistoryRequestT& request, const GetExecutionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::GetExecutionHistory, request, handler, context);
        }
 
        virtual Model::ListActivitiesOutcome ListActivities(const Model::ListActivitiesRequest& request = {}) const;
 
        template<typename ListActivitiesRequestT = Model::ListActivitiesRequest>
        Model::ListActivitiesOutcomeCallable ListActivitiesCallable(const ListActivitiesRequestT& request = {}) const
        {
            return SubmitCallable(&SFNClient::ListActivities, request);
        }
 
        template<typename ListActivitiesRequestT = Model::ListActivitiesRequest>
        void ListActivitiesAsync(const ListActivitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListActivitiesRequestT& request = {}) const
        {
            return SubmitAsync(&SFNClient::ListActivities, request, handler, context);
        }
 
        virtual Model::ListExecutionsOutcome ListExecutions(const Model::ListExecutionsRequest& request = {}) const;
 
        template<typename ListExecutionsRequestT = Model::ListExecutionsRequest>
        Model::ListExecutionsOutcomeCallable ListExecutionsCallable(const ListExecutionsRequestT& request = {}) const
        {
            return SubmitCallable(&SFNClient::ListExecutions, request);
        }
 
        template<typename ListExecutionsRequestT = Model::ListExecutionsRequest>
        void ListExecutionsAsync(const ListExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListExecutionsRequestT& request = {}) const
        {
            return SubmitAsync(&SFNClient::ListExecutions, request, handler, context);
        }
 
        virtual Model::ListMapRunsOutcome ListMapRuns(const Model::ListMapRunsRequest& request) const;
 
        template<typename ListMapRunsRequestT = Model::ListMapRunsRequest>
        Model::ListMapRunsOutcomeCallable ListMapRunsCallable(const ListMapRunsRequestT& request) const
        {
            return SubmitCallable(&SFNClient::ListMapRuns, request);
        }
 
        template<typename ListMapRunsRequestT = Model::ListMapRunsRequest>
        void ListMapRunsAsync(const ListMapRunsRequestT& request, const ListMapRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::ListMapRuns, request, handler, context);
        }
 
        virtual Model::ListStateMachineAliasesOutcome ListStateMachineAliases(const Model::ListStateMachineAliasesRequest& request) const;
 
        template<typename ListStateMachineAliasesRequestT = Model::ListStateMachineAliasesRequest>
        Model::ListStateMachineAliasesOutcomeCallable ListStateMachineAliasesCallable(const ListStateMachineAliasesRequestT& request) const
        {
            return SubmitCallable(&SFNClient::ListStateMachineAliases, request);
        }
 
        template<typename ListStateMachineAliasesRequestT = Model::ListStateMachineAliasesRequest>
        void ListStateMachineAliasesAsync(const ListStateMachineAliasesRequestT& request, const ListStateMachineAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::ListStateMachineAliases, request, handler, context);
        }
 
        virtual Model::ListStateMachineVersionsOutcome ListStateMachineVersions(const Model::ListStateMachineVersionsRequest& request) const;
 
        template<typename ListStateMachineVersionsRequestT = Model::ListStateMachineVersionsRequest>
        Model::ListStateMachineVersionsOutcomeCallable ListStateMachineVersionsCallable(const ListStateMachineVersionsRequestT& request) const
        {
            return SubmitCallable(&SFNClient::ListStateMachineVersions, request);
        }
 
        template<typename ListStateMachineVersionsRequestT = Model::ListStateMachineVersionsRequest>
        void ListStateMachineVersionsAsync(const ListStateMachineVersionsRequestT& request, const ListStateMachineVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::ListStateMachineVersions, request, handler, context);
        }
 
        virtual Model::ListStateMachinesOutcome ListStateMachines(const Model::ListStateMachinesRequest& request = {}) const;
 
        template<typename ListStateMachinesRequestT = Model::ListStateMachinesRequest>
        Model::ListStateMachinesOutcomeCallable ListStateMachinesCallable(const ListStateMachinesRequestT& request = {}) const
        {
            return SubmitCallable(&SFNClient::ListStateMachines, request);
        }
 
        template<typename ListStateMachinesRequestT = Model::ListStateMachinesRequest>
        void ListStateMachinesAsync(const ListStateMachinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStateMachinesRequestT& request = {}) const
        {
            return SubmitAsync(&SFNClient::ListStateMachines, 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(&SFNClient::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(&SFNClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PublishStateMachineVersionOutcome PublishStateMachineVersion(const Model::PublishStateMachineVersionRequest& request) const;
 
        template<typename PublishStateMachineVersionRequestT = Model::PublishStateMachineVersionRequest>
        Model::PublishStateMachineVersionOutcomeCallable PublishStateMachineVersionCallable(const PublishStateMachineVersionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::PublishStateMachineVersion, request);
        }
 
        template<typename PublishStateMachineVersionRequestT = Model::PublishStateMachineVersionRequest>
        void PublishStateMachineVersionAsync(const PublishStateMachineVersionRequestT& request, const PublishStateMachineVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::PublishStateMachineVersion, request, handler, context);
        }
 
        virtual Model::RedriveExecutionOutcome RedriveExecution(const Model::RedriveExecutionRequest& request) const;
 
        template<typename RedriveExecutionRequestT = Model::RedriveExecutionRequest>
        Model::RedriveExecutionOutcomeCallable RedriveExecutionCallable(const RedriveExecutionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::RedriveExecution, request);
        }
 
        template<typename RedriveExecutionRequestT = Model::RedriveExecutionRequest>
        void RedriveExecutionAsync(const RedriveExecutionRequestT& request, const RedriveExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::RedriveExecution, request, handler, context);
        }
 
        virtual Model::SendTaskFailureOutcome SendTaskFailure(const Model::SendTaskFailureRequest& request) const;
 
        template<typename SendTaskFailureRequestT = Model::SendTaskFailureRequest>
        Model::SendTaskFailureOutcomeCallable SendTaskFailureCallable(const SendTaskFailureRequestT& request) const
        {
            return SubmitCallable(&SFNClient::SendTaskFailure, request);
        }
 
        template<typename SendTaskFailureRequestT = Model::SendTaskFailureRequest>
        void SendTaskFailureAsync(const SendTaskFailureRequestT& request, const SendTaskFailureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::SendTaskFailure, request, handler, context);
        }
 
        virtual Model::SendTaskHeartbeatOutcome SendTaskHeartbeat(const Model::SendTaskHeartbeatRequest& request) const;
 
        template<typename SendTaskHeartbeatRequestT = Model::SendTaskHeartbeatRequest>
        Model::SendTaskHeartbeatOutcomeCallable SendTaskHeartbeatCallable(const SendTaskHeartbeatRequestT& request) const
        {
            return SubmitCallable(&SFNClient::SendTaskHeartbeat, request);
        }
 
        template<typename SendTaskHeartbeatRequestT = Model::SendTaskHeartbeatRequest>
        void SendTaskHeartbeatAsync(const SendTaskHeartbeatRequestT& request, const SendTaskHeartbeatResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::SendTaskHeartbeat, request, handler, context);
        }
 
        virtual Model::SendTaskSuccessOutcome SendTaskSuccess(const Model::SendTaskSuccessRequest& request) const;
 
        template<typename SendTaskSuccessRequestT = Model::SendTaskSuccessRequest>
        Model::SendTaskSuccessOutcomeCallable SendTaskSuccessCallable(const SendTaskSuccessRequestT& request) const
        {
            return SubmitCallable(&SFNClient::SendTaskSuccess, request);
        }
 
        template<typename SendTaskSuccessRequestT = Model::SendTaskSuccessRequest>
        void SendTaskSuccessAsync(const SendTaskSuccessRequestT& request, const SendTaskSuccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::SendTaskSuccess, request, handler, context);
        }
 
        virtual Model::StartExecutionOutcome StartExecution(const Model::StartExecutionRequest& request) const;
 
        template<typename StartExecutionRequestT = Model::StartExecutionRequest>
        Model::StartExecutionOutcomeCallable StartExecutionCallable(const StartExecutionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::StartExecution, request);
        }
 
        template<typename StartExecutionRequestT = Model::StartExecutionRequest>
        void StartExecutionAsync(const StartExecutionRequestT& request, const StartExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::StartExecution, request, handler, context);
        }
 
        virtual Model::StartSyncExecutionOutcome StartSyncExecution(const Model::StartSyncExecutionRequest& request) const;
 
        template<typename StartSyncExecutionRequestT = Model::StartSyncExecutionRequest>
        Model::StartSyncExecutionOutcomeCallable StartSyncExecutionCallable(const StartSyncExecutionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::StartSyncExecution, request);
        }
 
        template<typename StartSyncExecutionRequestT = Model::StartSyncExecutionRequest>
        void StartSyncExecutionAsync(const StartSyncExecutionRequestT& request, const StartSyncExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::StartSyncExecution, request, handler, context);
        }
 
        virtual Model::StopExecutionOutcome StopExecution(const Model::StopExecutionRequest& request) const;
 
        template<typename StopExecutionRequestT = Model::StopExecutionRequest>
        Model::StopExecutionOutcomeCallable StopExecutionCallable(const StopExecutionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::StopExecution, request);
        }
 
        template<typename StopExecutionRequestT = Model::StopExecutionRequest>
        void StopExecutionAsync(const StopExecutionRequestT& request, const StopExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::StopExecution, 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(&SFNClient::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(&SFNClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestStateOutcome TestState(const Model::TestStateRequest& request) const;
 
        template<typename TestStateRequestT = Model::TestStateRequest>
        Model::TestStateOutcomeCallable TestStateCallable(const TestStateRequestT& request) const
        {
            return SubmitCallable(&SFNClient::TestState, request);
        }
 
        template<typename TestStateRequestT = Model::TestStateRequest>
        void TestStateAsync(const TestStateRequestT& request, const TestStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::TestState, 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(&SFNClient::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(&SFNClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateMapRunOutcome UpdateMapRun(const Model::UpdateMapRunRequest& request) const;
 
        template<typename UpdateMapRunRequestT = Model::UpdateMapRunRequest>
        Model::UpdateMapRunOutcomeCallable UpdateMapRunCallable(const UpdateMapRunRequestT& request) const
        {
            return SubmitCallable(&SFNClient::UpdateMapRun, request);
        }
 
        template<typename UpdateMapRunRequestT = Model::UpdateMapRunRequest>
        void UpdateMapRunAsync(const UpdateMapRunRequestT& request, const UpdateMapRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::UpdateMapRun, request, handler, context);
        }
 
        virtual Model::UpdateStateMachineOutcome UpdateStateMachine(const Model::UpdateStateMachineRequest& request) const;
 
        template<typename UpdateStateMachineRequestT = Model::UpdateStateMachineRequest>
        Model::UpdateStateMachineOutcomeCallable UpdateStateMachineCallable(const UpdateStateMachineRequestT& request) const
        {
            return SubmitCallable(&SFNClient::UpdateStateMachine, request);
        }
 
        template<typename UpdateStateMachineRequestT = Model::UpdateStateMachineRequest>
        void UpdateStateMachineAsync(const UpdateStateMachineRequestT& request, const UpdateStateMachineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::UpdateStateMachine, request, handler, context);
        }
 
        virtual Model::UpdateStateMachineAliasOutcome UpdateStateMachineAlias(const Model::UpdateStateMachineAliasRequest& request) const;
 
        template<typename UpdateStateMachineAliasRequestT = Model::UpdateStateMachineAliasRequest>
        Model::UpdateStateMachineAliasOutcomeCallable UpdateStateMachineAliasCallable(const UpdateStateMachineAliasRequestT& request) const
        {
            return SubmitCallable(&SFNClient::UpdateStateMachineAlias, request);
        }
 
        template<typename UpdateStateMachineAliasRequestT = Model::UpdateStateMachineAliasRequest>
        void UpdateStateMachineAliasAsync(const UpdateStateMachineAliasRequestT& request, const UpdateStateMachineAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::UpdateStateMachineAlias, request, handler, context);
        }
 
        virtual Model::ValidateStateMachineDefinitionOutcome ValidateStateMachineDefinition(const Model::ValidateStateMachineDefinitionRequest& request) const;
 
        template<typename ValidateStateMachineDefinitionRequestT = Model::ValidateStateMachineDefinitionRequest>
        Model::ValidateStateMachineDefinitionOutcomeCallable ValidateStateMachineDefinitionCallable(const ValidateStateMachineDefinitionRequestT& request) const
        {
            return SubmitCallable(&SFNClient::ValidateStateMachineDefinition, request);
        }
 
        template<typename ValidateStateMachineDefinitionRequestT = Model::ValidateStateMachineDefinitionRequest>
        void ValidateStateMachineDefinitionAsync(const ValidateStateMachineDefinitionRequestT& request, const ValidateStateMachineDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SFNClient::ValidateStateMachineDefinition, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SFNEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SFNClient>;
      void init(const SFNClientConfiguration& clientConfiguration);
 
      SFNClientConfiguration m_clientConfiguration;
      std::shared_ptr<SFNEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SFN
} // namespace Aws