SFNClient.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/states/SFNServiceClientModel.h>
#include <aws/states/SFN_EXPORTS.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