SWFClient.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/swf/SWFPaginationBase.h>
#include <aws/swf/SWFServiceClientModel.h>
#include <aws/swf/SWF_EXPORTS.h>
 
namespace Aws {
namespace SWF {
class AWS_SWF_API SWFClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<SWFClient>,
                              public SWFPaginationBase<SWFClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SWFClientConfiguration ClientConfigurationType;
  typedef SWFEndpointProvider EndpointProviderType;
 
  SWFClient(const Aws::SWF::SWFClientConfiguration& clientConfiguration = Aws::SWF::SWFClientConfiguration(),
            std::shared_ptr<SWFEndpointProviderBase> endpointProvider = nullptr);
 
  SWFClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SWFEndpointProviderBase> endpointProvider = nullptr,
            const Aws::SWF::SWFClientConfiguration& clientConfiguration = Aws::SWF::SWFClientConfiguration());
 
  SWFClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<SWFEndpointProviderBase> endpointProvider = nullptr,
            const Aws::SWF::SWFClientConfiguration& clientConfiguration = Aws::SWF::SWFClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SWFClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SWFClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SWFClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SWFClient();
 
  virtual Model::CountClosedWorkflowExecutionsOutcome CountClosedWorkflowExecutions(
      const Model::CountClosedWorkflowExecutionsRequest& request) const;
 
  template <typename CountClosedWorkflowExecutionsRequestT = Model::CountClosedWorkflowExecutionsRequest>
  Model::CountClosedWorkflowExecutionsOutcomeCallable CountClosedWorkflowExecutionsCallable(
      const CountClosedWorkflowExecutionsRequestT& request) const {
    return SubmitCallable(&SWFClient::CountClosedWorkflowExecutions, request);
  }
 
  template <typename CountClosedWorkflowExecutionsRequestT = Model::CountClosedWorkflowExecutionsRequest>
  void CountClosedWorkflowExecutionsAsync(const CountClosedWorkflowExecutionsRequestT& request,
                                          const CountClosedWorkflowExecutionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::CountClosedWorkflowExecutions, request, handler, context);
  }
 
  virtual Model::CountOpenWorkflowExecutionsOutcome CountOpenWorkflowExecutions(
      const Model::CountOpenWorkflowExecutionsRequest& request) const;
 
  template <typename CountOpenWorkflowExecutionsRequestT = Model::CountOpenWorkflowExecutionsRequest>
  Model::CountOpenWorkflowExecutionsOutcomeCallable CountOpenWorkflowExecutionsCallable(
      const CountOpenWorkflowExecutionsRequestT& request) const {
    return SubmitCallable(&SWFClient::CountOpenWorkflowExecutions, request);
  }
 
  template <typename CountOpenWorkflowExecutionsRequestT = Model::CountOpenWorkflowExecutionsRequest>
  void CountOpenWorkflowExecutionsAsync(const CountOpenWorkflowExecutionsRequestT& request,
                                        const CountOpenWorkflowExecutionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::CountOpenWorkflowExecutions, request, handler, context);
  }
 
  virtual Model::CountPendingActivityTasksOutcome CountPendingActivityTasks(const Model::CountPendingActivityTasksRequest& request) const;
 
  template <typename CountPendingActivityTasksRequestT = Model::CountPendingActivityTasksRequest>
  Model::CountPendingActivityTasksOutcomeCallable CountPendingActivityTasksCallable(
      const CountPendingActivityTasksRequestT& request) const {
    return SubmitCallable(&SWFClient::CountPendingActivityTasks, request);
  }
 
  template <typename CountPendingActivityTasksRequestT = Model::CountPendingActivityTasksRequest>
  void CountPendingActivityTasksAsync(const CountPendingActivityTasksRequestT& request,
                                      const CountPendingActivityTasksResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::CountPendingActivityTasks, request, handler, context);
  }
 
  virtual Model::CountPendingDecisionTasksOutcome CountPendingDecisionTasks(const Model::CountPendingDecisionTasksRequest& request) const;
 
  template <typename CountPendingDecisionTasksRequestT = Model::CountPendingDecisionTasksRequest>
  Model::CountPendingDecisionTasksOutcomeCallable CountPendingDecisionTasksCallable(
      const CountPendingDecisionTasksRequestT& request) const {
    return SubmitCallable(&SWFClient::CountPendingDecisionTasks, request);
  }
 
  template <typename CountPendingDecisionTasksRequestT = Model::CountPendingDecisionTasksRequest>
  void CountPendingDecisionTasksAsync(const CountPendingDecisionTasksRequestT& request,
                                      const CountPendingDecisionTasksResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::CountPendingDecisionTasks, request, handler, context);
  }
 
  virtual Model::DeleteActivityTypeOutcome DeleteActivityType(const Model::DeleteActivityTypeRequest& request) const;
 
  template <typename DeleteActivityTypeRequestT = Model::DeleteActivityTypeRequest>
  Model::DeleteActivityTypeOutcomeCallable DeleteActivityTypeCallable(const DeleteActivityTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::DeleteActivityType, request);
  }
 
  template <typename DeleteActivityTypeRequestT = Model::DeleteActivityTypeRequest>
  void DeleteActivityTypeAsync(const DeleteActivityTypeRequestT& request, const DeleteActivityTypeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DeleteActivityType, request, handler, context);
  }
 
  virtual Model::DeleteWorkflowTypeOutcome DeleteWorkflowType(const Model::DeleteWorkflowTypeRequest& request) const;
 
  template <typename DeleteWorkflowTypeRequestT = Model::DeleteWorkflowTypeRequest>
  Model::DeleteWorkflowTypeOutcomeCallable DeleteWorkflowTypeCallable(const DeleteWorkflowTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::DeleteWorkflowType, request);
  }
 
  template <typename DeleteWorkflowTypeRequestT = Model::DeleteWorkflowTypeRequest>
  void DeleteWorkflowTypeAsync(const DeleteWorkflowTypeRequestT& request, const DeleteWorkflowTypeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DeleteWorkflowType, request, handler, context);
  }
 
  virtual Model::DeprecateActivityTypeOutcome DeprecateActivityType(const Model::DeprecateActivityTypeRequest& request) const;
 
  template <typename DeprecateActivityTypeRequestT = Model::DeprecateActivityTypeRequest>
  Model::DeprecateActivityTypeOutcomeCallable DeprecateActivityTypeCallable(const DeprecateActivityTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::DeprecateActivityType, request);
  }
 
  template <typename DeprecateActivityTypeRequestT = Model::DeprecateActivityTypeRequest>
  void DeprecateActivityTypeAsync(const DeprecateActivityTypeRequestT& request, const DeprecateActivityTypeResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DeprecateActivityType, request, handler, context);
  }
 
  virtual Model::DeprecateDomainOutcome DeprecateDomain(const Model::DeprecateDomainRequest& request) const;
 
  template <typename DeprecateDomainRequestT = Model::DeprecateDomainRequest>
  Model::DeprecateDomainOutcomeCallable DeprecateDomainCallable(const DeprecateDomainRequestT& request) const {
    return SubmitCallable(&SWFClient::DeprecateDomain, request);
  }
 
  template <typename DeprecateDomainRequestT = Model::DeprecateDomainRequest>
  void DeprecateDomainAsync(const DeprecateDomainRequestT& request, const DeprecateDomainResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DeprecateDomain, request, handler, context);
  }
 
  virtual Model::DeprecateWorkflowTypeOutcome DeprecateWorkflowType(const Model::DeprecateWorkflowTypeRequest& request) const;
 
  template <typename DeprecateWorkflowTypeRequestT = Model::DeprecateWorkflowTypeRequest>
  Model::DeprecateWorkflowTypeOutcomeCallable DeprecateWorkflowTypeCallable(const DeprecateWorkflowTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::DeprecateWorkflowType, request);
  }
 
  template <typename DeprecateWorkflowTypeRequestT = Model::DeprecateWorkflowTypeRequest>
  void DeprecateWorkflowTypeAsync(const DeprecateWorkflowTypeRequestT& request, const DeprecateWorkflowTypeResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DeprecateWorkflowType, request, handler, context);
  }
 
  virtual Model::DescribeActivityTypeOutcome DescribeActivityType(const Model::DescribeActivityTypeRequest& request) const;
 
  template <typename DescribeActivityTypeRequestT = Model::DescribeActivityTypeRequest>
  Model::DescribeActivityTypeOutcomeCallable DescribeActivityTypeCallable(const DescribeActivityTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::DescribeActivityType, request);
  }
 
  template <typename DescribeActivityTypeRequestT = Model::DescribeActivityTypeRequest>
  void DescribeActivityTypeAsync(const DescribeActivityTypeRequestT& request, const DescribeActivityTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DescribeActivityType, request, handler, context);
  }
 
  virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const;
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const DescribeDomainRequestT& request) const {
    return SubmitCallable(&SWFClient::DescribeDomain, request);
  }
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  void DescribeDomainAsync(const DescribeDomainRequestT& request, const DescribeDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DescribeDomain, request, handler, context);
  }
 
  virtual Model::DescribeWorkflowExecutionOutcome DescribeWorkflowExecution(const Model::DescribeWorkflowExecutionRequest& request) const;
 
  template <typename DescribeWorkflowExecutionRequestT = Model::DescribeWorkflowExecutionRequest>
  Model::DescribeWorkflowExecutionOutcomeCallable DescribeWorkflowExecutionCallable(
      const DescribeWorkflowExecutionRequestT& request) const {
    return SubmitCallable(&SWFClient::DescribeWorkflowExecution, request);
  }
 
  template <typename DescribeWorkflowExecutionRequestT = Model::DescribeWorkflowExecutionRequest>
  void DescribeWorkflowExecutionAsync(const DescribeWorkflowExecutionRequestT& request,
                                      const DescribeWorkflowExecutionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DescribeWorkflowExecution, request, handler, context);
  }
 
  virtual Model::DescribeWorkflowTypeOutcome DescribeWorkflowType(const Model::DescribeWorkflowTypeRequest& request) const;
 
  template <typename DescribeWorkflowTypeRequestT = Model::DescribeWorkflowTypeRequest>
  Model::DescribeWorkflowTypeOutcomeCallable DescribeWorkflowTypeCallable(const DescribeWorkflowTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::DescribeWorkflowType, request);
  }
 
  template <typename DescribeWorkflowTypeRequestT = Model::DescribeWorkflowTypeRequest>
  void DescribeWorkflowTypeAsync(const DescribeWorkflowTypeRequestT& request, const DescribeWorkflowTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::DescribeWorkflowType, request, handler, context);
  }
 
  virtual Model::GetWorkflowExecutionHistoryOutcome GetWorkflowExecutionHistory(
      const Model::GetWorkflowExecutionHistoryRequest& request) const;
 
  template <typename GetWorkflowExecutionHistoryRequestT = Model::GetWorkflowExecutionHistoryRequest>
  Model::GetWorkflowExecutionHistoryOutcomeCallable GetWorkflowExecutionHistoryCallable(
      const GetWorkflowExecutionHistoryRequestT& request) const {
    return SubmitCallable(&SWFClient::GetWorkflowExecutionHistory, request);
  }
 
  template <typename GetWorkflowExecutionHistoryRequestT = Model::GetWorkflowExecutionHistoryRequest>
  void GetWorkflowExecutionHistoryAsync(const GetWorkflowExecutionHistoryRequestT& request,
                                        const GetWorkflowExecutionHistoryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::GetWorkflowExecutionHistory, request, handler, context);
  }
 
  virtual Model::ListActivityTypesOutcome ListActivityTypes(const Model::ListActivityTypesRequest& request) const;
 
  template <typename ListActivityTypesRequestT = Model::ListActivityTypesRequest>
  Model::ListActivityTypesOutcomeCallable ListActivityTypesCallable(const ListActivityTypesRequestT& request) const {
    return SubmitCallable(&SWFClient::ListActivityTypes, request);
  }
 
  template <typename ListActivityTypesRequestT = Model::ListActivityTypesRequest>
  void ListActivityTypesAsync(const ListActivityTypesRequestT& request, const ListActivityTypesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::ListActivityTypes, request, handler, context);
  }
 
  virtual Model::ListClosedWorkflowExecutionsOutcome ListClosedWorkflowExecutions(
      const Model::ListClosedWorkflowExecutionsRequest& request) const;
 
  template <typename ListClosedWorkflowExecutionsRequestT = Model::ListClosedWorkflowExecutionsRequest>
  Model::ListClosedWorkflowExecutionsOutcomeCallable ListClosedWorkflowExecutionsCallable(
      const ListClosedWorkflowExecutionsRequestT& request) const {
    return SubmitCallable(&SWFClient::ListClosedWorkflowExecutions, request);
  }
 
  template <typename ListClosedWorkflowExecutionsRequestT = Model::ListClosedWorkflowExecutionsRequest>
  void ListClosedWorkflowExecutionsAsync(const ListClosedWorkflowExecutionsRequestT& request,
                                         const ListClosedWorkflowExecutionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::ListClosedWorkflowExecutions, request, handler, context);
  }
 
  virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request) const;
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request) const {
    return SubmitCallable(&SWFClient::ListDomains, request);
  }
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  void ListDomainsAsync(const ListDomainsRequestT& request, const ListDomainsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::ListDomains, request, handler, context);
  }
 
  virtual Model::ListOpenWorkflowExecutionsOutcome ListOpenWorkflowExecutions(
      const Model::ListOpenWorkflowExecutionsRequest& request) const;
 
  template <typename ListOpenWorkflowExecutionsRequestT = Model::ListOpenWorkflowExecutionsRequest>
  Model::ListOpenWorkflowExecutionsOutcomeCallable ListOpenWorkflowExecutionsCallable(
      const ListOpenWorkflowExecutionsRequestT& request) const {
    return SubmitCallable(&SWFClient::ListOpenWorkflowExecutions, request);
  }
 
  template <typename ListOpenWorkflowExecutionsRequestT = Model::ListOpenWorkflowExecutionsRequest>
  void ListOpenWorkflowExecutionsAsync(const ListOpenWorkflowExecutionsRequestT& request,
                                       const ListOpenWorkflowExecutionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::ListOpenWorkflowExecutions, 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(&SWFClient::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(&SWFClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkflowTypesOutcome ListWorkflowTypes(const Model::ListWorkflowTypesRequest& request) const;
 
  template <typename ListWorkflowTypesRequestT = Model::ListWorkflowTypesRequest>
  Model::ListWorkflowTypesOutcomeCallable ListWorkflowTypesCallable(const ListWorkflowTypesRequestT& request) const {
    return SubmitCallable(&SWFClient::ListWorkflowTypes, request);
  }
 
  template <typename ListWorkflowTypesRequestT = Model::ListWorkflowTypesRequest>
  void ListWorkflowTypesAsync(const ListWorkflowTypesRequestT& request, const ListWorkflowTypesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::ListWorkflowTypes, request, handler, context);
  }
 
  virtual Model::PollForActivityTaskOutcome PollForActivityTask(const Model::PollForActivityTaskRequest& request) const;
 
  template <typename PollForActivityTaskRequestT = Model::PollForActivityTaskRequest>
  Model::PollForActivityTaskOutcomeCallable PollForActivityTaskCallable(const PollForActivityTaskRequestT& request) const {
    return SubmitCallable(&SWFClient::PollForActivityTask, request);
  }
 
  template <typename PollForActivityTaskRequestT = Model::PollForActivityTaskRequest>
  void PollForActivityTaskAsync(const PollForActivityTaskRequestT& request, const PollForActivityTaskResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::PollForActivityTask, request, handler, context);
  }
 
  virtual Model::PollForDecisionTaskOutcome PollForDecisionTask(const Model::PollForDecisionTaskRequest& request) const;
 
  template <typename PollForDecisionTaskRequestT = Model::PollForDecisionTaskRequest>
  Model::PollForDecisionTaskOutcomeCallable PollForDecisionTaskCallable(const PollForDecisionTaskRequestT& request) const {
    return SubmitCallable(&SWFClient::PollForDecisionTask, request);
  }
 
  template <typename PollForDecisionTaskRequestT = Model::PollForDecisionTaskRequest>
  void PollForDecisionTaskAsync(const PollForDecisionTaskRequestT& request, const PollForDecisionTaskResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::PollForDecisionTask, request, handler, context);
  }
 
  virtual Model::RecordActivityTaskHeartbeatOutcome RecordActivityTaskHeartbeat(
      const Model::RecordActivityTaskHeartbeatRequest& request) const;
 
  template <typename RecordActivityTaskHeartbeatRequestT = Model::RecordActivityTaskHeartbeatRequest>
  Model::RecordActivityTaskHeartbeatOutcomeCallable RecordActivityTaskHeartbeatCallable(
      const RecordActivityTaskHeartbeatRequestT& request) const {
    return SubmitCallable(&SWFClient::RecordActivityTaskHeartbeat, request);
  }
 
  template <typename RecordActivityTaskHeartbeatRequestT = Model::RecordActivityTaskHeartbeatRequest>
  void RecordActivityTaskHeartbeatAsync(const RecordActivityTaskHeartbeatRequestT& request,
                                        const RecordActivityTaskHeartbeatResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RecordActivityTaskHeartbeat, request, handler, context);
  }
 
  virtual Model::RegisterActivityTypeOutcome RegisterActivityType(const Model::RegisterActivityTypeRequest& request) const;
 
  template <typename RegisterActivityTypeRequestT = Model::RegisterActivityTypeRequest>
  Model::RegisterActivityTypeOutcomeCallable RegisterActivityTypeCallable(const RegisterActivityTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::RegisterActivityType, request);
  }
 
  template <typename RegisterActivityTypeRequestT = Model::RegisterActivityTypeRequest>
  void RegisterActivityTypeAsync(const RegisterActivityTypeRequestT& request, const RegisterActivityTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RegisterActivityType, request, handler, context);
  }
 
  virtual Model::RegisterDomainOutcome RegisterDomain(const Model::RegisterDomainRequest& request) const;
 
  template <typename RegisterDomainRequestT = Model::RegisterDomainRequest>
  Model::RegisterDomainOutcomeCallable RegisterDomainCallable(const RegisterDomainRequestT& request) const {
    return SubmitCallable(&SWFClient::RegisterDomain, request);
  }
 
  template <typename RegisterDomainRequestT = Model::RegisterDomainRequest>
  void RegisterDomainAsync(const RegisterDomainRequestT& request, const RegisterDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RegisterDomain, request, handler, context);
  }
 
  virtual Model::RegisterWorkflowTypeOutcome RegisterWorkflowType(const Model::RegisterWorkflowTypeRequest& request) const;
 
  template <typename RegisterWorkflowTypeRequestT = Model::RegisterWorkflowTypeRequest>
  Model::RegisterWorkflowTypeOutcomeCallable RegisterWorkflowTypeCallable(const RegisterWorkflowTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::RegisterWorkflowType, request);
  }
 
  template <typename RegisterWorkflowTypeRequestT = Model::RegisterWorkflowTypeRequest>
  void RegisterWorkflowTypeAsync(const RegisterWorkflowTypeRequestT& request, const RegisterWorkflowTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RegisterWorkflowType, request, handler, context);
  }
 
  virtual Model::RequestCancelWorkflowExecutionOutcome RequestCancelWorkflowExecution(
      const Model::RequestCancelWorkflowExecutionRequest& request) const;
 
  template <typename RequestCancelWorkflowExecutionRequestT = Model::RequestCancelWorkflowExecutionRequest>
  Model::RequestCancelWorkflowExecutionOutcomeCallable RequestCancelWorkflowExecutionCallable(
      const RequestCancelWorkflowExecutionRequestT& request) const {
    return SubmitCallable(&SWFClient::RequestCancelWorkflowExecution, request);
  }
 
  template <typename RequestCancelWorkflowExecutionRequestT = Model::RequestCancelWorkflowExecutionRequest>
  void RequestCancelWorkflowExecutionAsync(const RequestCancelWorkflowExecutionRequestT& request,
                                           const RequestCancelWorkflowExecutionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RequestCancelWorkflowExecution, request, handler, context);
  }
 
  virtual Model::RespondActivityTaskCanceledOutcome RespondActivityTaskCanceled(
      const Model::RespondActivityTaskCanceledRequest& request) const;
 
  template <typename RespondActivityTaskCanceledRequestT = Model::RespondActivityTaskCanceledRequest>
  Model::RespondActivityTaskCanceledOutcomeCallable RespondActivityTaskCanceledCallable(
      const RespondActivityTaskCanceledRequestT& request) const {
    return SubmitCallable(&SWFClient::RespondActivityTaskCanceled, request);
  }
 
  template <typename RespondActivityTaskCanceledRequestT = Model::RespondActivityTaskCanceledRequest>
  void RespondActivityTaskCanceledAsync(const RespondActivityTaskCanceledRequestT& request,
                                        const RespondActivityTaskCanceledResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RespondActivityTaskCanceled, request, handler, context);
  }
 
  virtual Model::RespondActivityTaskCompletedOutcome RespondActivityTaskCompleted(
      const Model::RespondActivityTaskCompletedRequest& request) const;
 
  template <typename RespondActivityTaskCompletedRequestT = Model::RespondActivityTaskCompletedRequest>
  Model::RespondActivityTaskCompletedOutcomeCallable RespondActivityTaskCompletedCallable(
      const RespondActivityTaskCompletedRequestT& request) const {
    return SubmitCallable(&SWFClient::RespondActivityTaskCompleted, request);
  }
 
  template <typename RespondActivityTaskCompletedRequestT = Model::RespondActivityTaskCompletedRequest>
  void RespondActivityTaskCompletedAsync(const RespondActivityTaskCompletedRequestT& request,
                                         const RespondActivityTaskCompletedResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RespondActivityTaskCompleted, request, handler, context);
  }
 
  virtual Model::RespondActivityTaskFailedOutcome RespondActivityTaskFailed(const Model::RespondActivityTaskFailedRequest& request) const;
 
  template <typename RespondActivityTaskFailedRequestT = Model::RespondActivityTaskFailedRequest>
  Model::RespondActivityTaskFailedOutcomeCallable RespondActivityTaskFailedCallable(
      const RespondActivityTaskFailedRequestT& request) const {
    return SubmitCallable(&SWFClient::RespondActivityTaskFailed, request);
  }
 
  template <typename RespondActivityTaskFailedRequestT = Model::RespondActivityTaskFailedRequest>
  void RespondActivityTaskFailedAsync(const RespondActivityTaskFailedRequestT& request,
                                      const RespondActivityTaskFailedResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RespondActivityTaskFailed, request, handler, context);
  }
 
  virtual Model::RespondDecisionTaskCompletedOutcome RespondDecisionTaskCompleted(
      const Model::RespondDecisionTaskCompletedRequest& request) const;
 
  template <typename RespondDecisionTaskCompletedRequestT = Model::RespondDecisionTaskCompletedRequest>
  Model::RespondDecisionTaskCompletedOutcomeCallable RespondDecisionTaskCompletedCallable(
      const RespondDecisionTaskCompletedRequestT& request) const {
    return SubmitCallable(&SWFClient::RespondDecisionTaskCompleted, request);
  }
 
  template <typename RespondDecisionTaskCompletedRequestT = Model::RespondDecisionTaskCompletedRequest>
  void RespondDecisionTaskCompletedAsync(const RespondDecisionTaskCompletedRequestT& request,
                                         const RespondDecisionTaskCompletedResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::RespondDecisionTaskCompleted, request, handler, context);
  }
 
  virtual Model::SignalWorkflowExecutionOutcome SignalWorkflowExecution(const Model::SignalWorkflowExecutionRequest& request) const;
 
  template <typename SignalWorkflowExecutionRequestT = Model::SignalWorkflowExecutionRequest>
  Model::SignalWorkflowExecutionOutcomeCallable SignalWorkflowExecutionCallable(const SignalWorkflowExecutionRequestT& request) const {
    return SubmitCallable(&SWFClient::SignalWorkflowExecution, request);
  }
 
  template <typename SignalWorkflowExecutionRequestT = Model::SignalWorkflowExecutionRequest>
  void SignalWorkflowExecutionAsync(const SignalWorkflowExecutionRequestT& request,
                                    const SignalWorkflowExecutionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::SignalWorkflowExecution, request, handler, context);
  }
 
  virtual Model::StartWorkflowExecutionOutcome StartWorkflowExecution(const Model::StartWorkflowExecutionRequest& request) const;
 
  template <typename StartWorkflowExecutionRequestT = Model::StartWorkflowExecutionRequest>
  Model::StartWorkflowExecutionOutcomeCallable StartWorkflowExecutionCallable(const StartWorkflowExecutionRequestT& request) const {
    return SubmitCallable(&SWFClient::StartWorkflowExecution, request);
  }
 
  template <typename StartWorkflowExecutionRequestT = Model::StartWorkflowExecutionRequest>
  void StartWorkflowExecutionAsync(const StartWorkflowExecutionRequestT& request,
                                   const StartWorkflowExecutionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::StartWorkflowExecution, 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(&SWFClient::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(&SWFClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateWorkflowExecutionOutcome TerminateWorkflowExecution(
      const Model::TerminateWorkflowExecutionRequest& request) const;
 
  template <typename TerminateWorkflowExecutionRequestT = Model::TerminateWorkflowExecutionRequest>
  Model::TerminateWorkflowExecutionOutcomeCallable TerminateWorkflowExecutionCallable(
      const TerminateWorkflowExecutionRequestT& request) const {
    return SubmitCallable(&SWFClient::TerminateWorkflowExecution, request);
  }
 
  template <typename TerminateWorkflowExecutionRequestT = Model::TerminateWorkflowExecutionRequest>
  void TerminateWorkflowExecutionAsync(const TerminateWorkflowExecutionRequestT& request,
                                       const TerminateWorkflowExecutionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::TerminateWorkflowExecution, request, handler, context);
  }
 
  virtual Model::UndeprecateActivityTypeOutcome UndeprecateActivityType(const Model::UndeprecateActivityTypeRequest& request) const;
 
  template <typename UndeprecateActivityTypeRequestT = Model::UndeprecateActivityTypeRequest>
  Model::UndeprecateActivityTypeOutcomeCallable UndeprecateActivityTypeCallable(const UndeprecateActivityTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::UndeprecateActivityType, request);
  }
 
  template <typename UndeprecateActivityTypeRequestT = Model::UndeprecateActivityTypeRequest>
  void UndeprecateActivityTypeAsync(const UndeprecateActivityTypeRequestT& request,
                                    const UndeprecateActivityTypeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::UndeprecateActivityType, request, handler, context);
  }
 
  virtual Model::UndeprecateDomainOutcome UndeprecateDomain(const Model::UndeprecateDomainRequest& request) const;
 
  template <typename UndeprecateDomainRequestT = Model::UndeprecateDomainRequest>
  Model::UndeprecateDomainOutcomeCallable UndeprecateDomainCallable(const UndeprecateDomainRequestT& request) const {
    return SubmitCallable(&SWFClient::UndeprecateDomain, request);
  }
 
  template <typename UndeprecateDomainRequestT = Model::UndeprecateDomainRequest>
  void UndeprecateDomainAsync(const UndeprecateDomainRequestT& request, const UndeprecateDomainResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::UndeprecateDomain, request, handler, context);
  }
 
  virtual Model::UndeprecateWorkflowTypeOutcome UndeprecateWorkflowType(const Model::UndeprecateWorkflowTypeRequest& request) const;
 
  template <typename UndeprecateWorkflowTypeRequestT = Model::UndeprecateWorkflowTypeRequest>
  Model::UndeprecateWorkflowTypeOutcomeCallable UndeprecateWorkflowTypeCallable(const UndeprecateWorkflowTypeRequestT& request) const {
    return SubmitCallable(&SWFClient::UndeprecateWorkflowType, request);
  }
 
  template <typename UndeprecateWorkflowTypeRequestT = Model::UndeprecateWorkflowTypeRequest>
  void UndeprecateWorkflowTypeAsync(const UndeprecateWorkflowTypeRequestT& request,
                                    const UndeprecateWorkflowTypeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SWFClient::UndeprecateWorkflowType, 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(&SWFClient::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(&SWFClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SWFEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SWFClient>;
  void init(const SWFClientConfiguration& clientConfiguration);
 
  SWFClientConfiguration m_clientConfiguration;
  std::shared_ptr<SWFEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SWF
}  // namespace Aws