SWFClient.h

 
#pragma once
#include <aws/swf/SWF_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/swf/SWFServiceClientModel.h>
 
namespace Aws
{
namespace SWF
{
  class AWS_SWF_API SWFClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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