3461 lines
262 KiB
C++
3461 lines
262 KiB
C++
/**
|
|
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
* SPDX-License-Identifier: Apache-2.0.
|
|
*/
|
|
|
|
#pragma once
|
|
#include <aws/swf/SWF_EXPORTS.h>
|
|
#include <aws/swf/SWFErrors.h>
|
|
#include <aws/core/client/AWSError.h>
|
|
#include <aws/core/client/ClientConfiguration.h>
|
|
#include <aws/core/client/AWSClient.h>
|
|
#include <aws/core/utils/memory/stl/AWSString.h>
|
|
#include <aws/core/utils/json/JsonSerializer.h>
|
|
#include <aws/swf/model/CountClosedWorkflowExecutionsResult.h>
|
|
#include <aws/swf/model/CountOpenWorkflowExecutionsResult.h>
|
|
#include <aws/swf/model/CountPendingActivityTasksResult.h>
|
|
#include <aws/swf/model/CountPendingDecisionTasksResult.h>
|
|
#include <aws/swf/model/DescribeActivityTypeResult.h>
|
|
#include <aws/swf/model/DescribeDomainResult.h>
|
|
#include <aws/swf/model/DescribeWorkflowExecutionResult.h>
|
|
#include <aws/swf/model/DescribeWorkflowTypeResult.h>
|
|
#include <aws/swf/model/GetWorkflowExecutionHistoryResult.h>
|
|
#include <aws/swf/model/ListActivityTypesResult.h>
|
|
#include <aws/swf/model/ListClosedWorkflowExecutionsResult.h>
|
|
#include <aws/swf/model/ListDomainsResult.h>
|
|
#include <aws/swf/model/ListOpenWorkflowExecutionsResult.h>
|
|
#include <aws/swf/model/ListTagsForResourceResult.h>
|
|
#include <aws/swf/model/ListWorkflowTypesResult.h>
|
|
#include <aws/swf/model/PollForActivityTaskResult.h>
|
|
#include <aws/swf/model/PollForDecisionTaskResult.h>
|
|
#include <aws/swf/model/RecordActivityTaskHeartbeatResult.h>
|
|
#include <aws/swf/model/StartWorkflowExecutionResult.h>
|
|
#include <aws/core/NoResult.h>
|
|
#include <aws/core/client/AsyncCallerContext.h>
|
|
#include <aws/core/http/HttpTypes.h>
|
|
#include <future>
|
|
#include <functional>
|
|
|
|
namespace Aws
|
|
{
|
|
|
|
namespace Http
|
|
{
|
|
class HttpClient;
|
|
class HttpClientFactory;
|
|
} // namespace Http
|
|
|
|
namespace Utils
|
|
{
|
|
template< typename R, typename E> class Outcome;
|
|
namespace Threading
|
|
{
|
|
class Executor;
|
|
} // namespace Threading
|
|
} // namespace Utils
|
|
|
|
namespace Auth
|
|
{
|
|
class AWSCredentials;
|
|
class AWSCredentialsProvider;
|
|
} // namespace Auth
|
|
|
|
namespace Client
|
|
{
|
|
class RetryStrategy;
|
|
} // namespace Client
|
|
|
|
namespace SWF
|
|
{
|
|
|
|
namespace Model
|
|
{
|
|
class CountClosedWorkflowExecutionsRequest;
|
|
class CountOpenWorkflowExecutionsRequest;
|
|
class CountPendingActivityTasksRequest;
|
|
class CountPendingDecisionTasksRequest;
|
|
class DeprecateActivityTypeRequest;
|
|
class DeprecateDomainRequest;
|
|
class DeprecateWorkflowTypeRequest;
|
|
class DescribeActivityTypeRequest;
|
|
class DescribeDomainRequest;
|
|
class DescribeWorkflowExecutionRequest;
|
|
class DescribeWorkflowTypeRequest;
|
|
class GetWorkflowExecutionHistoryRequest;
|
|
class ListActivityTypesRequest;
|
|
class ListClosedWorkflowExecutionsRequest;
|
|
class ListDomainsRequest;
|
|
class ListOpenWorkflowExecutionsRequest;
|
|
class ListTagsForResourceRequest;
|
|
class ListWorkflowTypesRequest;
|
|
class PollForActivityTaskRequest;
|
|
class PollForDecisionTaskRequest;
|
|
class RecordActivityTaskHeartbeatRequest;
|
|
class RegisterActivityTypeRequest;
|
|
class RegisterDomainRequest;
|
|
class RegisterWorkflowTypeRequest;
|
|
class RequestCancelWorkflowExecutionRequest;
|
|
class RespondActivityTaskCanceledRequest;
|
|
class RespondActivityTaskCompletedRequest;
|
|
class RespondActivityTaskFailedRequest;
|
|
class RespondDecisionTaskCompletedRequest;
|
|
class SignalWorkflowExecutionRequest;
|
|
class StartWorkflowExecutionRequest;
|
|
class TagResourceRequest;
|
|
class TerminateWorkflowExecutionRequest;
|
|
class UndeprecateActivityTypeRequest;
|
|
class UndeprecateDomainRequest;
|
|
class UndeprecateWorkflowTypeRequest;
|
|
class UntagResourceRequest;
|
|
|
|
typedef Aws::Utils::Outcome<CountClosedWorkflowExecutionsResult, SWFError> CountClosedWorkflowExecutionsOutcome;
|
|
typedef Aws::Utils::Outcome<CountOpenWorkflowExecutionsResult, SWFError> CountOpenWorkflowExecutionsOutcome;
|
|
typedef Aws::Utils::Outcome<CountPendingActivityTasksResult, SWFError> CountPendingActivityTasksOutcome;
|
|
typedef Aws::Utils::Outcome<CountPendingDecisionTasksResult, SWFError> CountPendingDecisionTasksOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> DeprecateActivityTypeOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> DeprecateDomainOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> DeprecateWorkflowTypeOutcome;
|
|
typedef Aws::Utils::Outcome<DescribeActivityTypeResult, SWFError> DescribeActivityTypeOutcome;
|
|
typedef Aws::Utils::Outcome<DescribeDomainResult, SWFError> DescribeDomainOutcome;
|
|
typedef Aws::Utils::Outcome<DescribeWorkflowExecutionResult, SWFError> DescribeWorkflowExecutionOutcome;
|
|
typedef Aws::Utils::Outcome<DescribeWorkflowTypeResult, SWFError> DescribeWorkflowTypeOutcome;
|
|
typedef Aws::Utils::Outcome<GetWorkflowExecutionHistoryResult, SWFError> GetWorkflowExecutionHistoryOutcome;
|
|
typedef Aws::Utils::Outcome<ListActivityTypesResult, SWFError> ListActivityTypesOutcome;
|
|
typedef Aws::Utils::Outcome<ListClosedWorkflowExecutionsResult, SWFError> ListClosedWorkflowExecutionsOutcome;
|
|
typedef Aws::Utils::Outcome<ListDomainsResult, SWFError> ListDomainsOutcome;
|
|
typedef Aws::Utils::Outcome<ListOpenWorkflowExecutionsResult, SWFError> ListOpenWorkflowExecutionsOutcome;
|
|
typedef Aws::Utils::Outcome<ListTagsForResourceResult, SWFError> ListTagsForResourceOutcome;
|
|
typedef Aws::Utils::Outcome<ListWorkflowTypesResult, SWFError> ListWorkflowTypesOutcome;
|
|
typedef Aws::Utils::Outcome<PollForActivityTaskResult, SWFError> PollForActivityTaskOutcome;
|
|
typedef Aws::Utils::Outcome<PollForDecisionTaskResult, SWFError> PollForDecisionTaskOutcome;
|
|
typedef Aws::Utils::Outcome<RecordActivityTaskHeartbeatResult, SWFError> RecordActivityTaskHeartbeatOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RegisterActivityTypeOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RegisterDomainOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RegisterWorkflowTypeOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RequestCancelWorkflowExecutionOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RespondActivityTaskCanceledOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RespondActivityTaskCompletedOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RespondActivityTaskFailedOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> RespondDecisionTaskCompletedOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> SignalWorkflowExecutionOutcome;
|
|
typedef Aws::Utils::Outcome<StartWorkflowExecutionResult, SWFError> StartWorkflowExecutionOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> TagResourceOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> TerminateWorkflowExecutionOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> UndeprecateActivityTypeOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> UndeprecateDomainOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> UndeprecateWorkflowTypeOutcome;
|
|
typedef Aws::Utils::Outcome<Aws::NoResult, SWFError> UntagResourceOutcome;
|
|
|
|
typedef std::future<CountClosedWorkflowExecutionsOutcome> CountClosedWorkflowExecutionsOutcomeCallable;
|
|
typedef std::future<CountOpenWorkflowExecutionsOutcome> CountOpenWorkflowExecutionsOutcomeCallable;
|
|
typedef std::future<CountPendingActivityTasksOutcome> CountPendingActivityTasksOutcomeCallable;
|
|
typedef std::future<CountPendingDecisionTasksOutcome> CountPendingDecisionTasksOutcomeCallable;
|
|
typedef std::future<DeprecateActivityTypeOutcome> DeprecateActivityTypeOutcomeCallable;
|
|
typedef std::future<DeprecateDomainOutcome> DeprecateDomainOutcomeCallable;
|
|
typedef std::future<DeprecateWorkflowTypeOutcome> DeprecateWorkflowTypeOutcomeCallable;
|
|
typedef std::future<DescribeActivityTypeOutcome> DescribeActivityTypeOutcomeCallable;
|
|
typedef std::future<DescribeDomainOutcome> DescribeDomainOutcomeCallable;
|
|
typedef std::future<DescribeWorkflowExecutionOutcome> DescribeWorkflowExecutionOutcomeCallable;
|
|
typedef std::future<DescribeWorkflowTypeOutcome> DescribeWorkflowTypeOutcomeCallable;
|
|
typedef std::future<GetWorkflowExecutionHistoryOutcome> GetWorkflowExecutionHistoryOutcomeCallable;
|
|
typedef std::future<ListActivityTypesOutcome> ListActivityTypesOutcomeCallable;
|
|
typedef std::future<ListClosedWorkflowExecutionsOutcome> ListClosedWorkflowExecutionsOutcomeCallable;
|
|
typedef std::future<ListDomainsOutcome> ListDomainsOutcomeCallable;
|
|
typedef std::future<ListOpenWorkflowExecutionsOutcome> ListOpenWorkflowExecutionsOutcomeCallable;
|
|
typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
|
|
typedef std::future<ListWorkflowTypesOutcome> ListWorkflowTypesOutcomeCallable;
|
|
typedef std::future<PollForActivityTaskOutcome> PollForActivityTaskOutcomeCallable;
|
|
typedef std::future<PollForDecisionTaskOutcome> PollForDecisionTaskOutcomeCallable;
|
|
typedef std::future<RecordActivityTaskHeartbeatOutcome> RecordActivityTaskHeartbeatOutcomeCallable;
|
|
typedef std::future<RegisterActivityTypeOutcome> RegisterActivityTypeOutcomeCallable;
|
|
typedef std::future<RegisterDomainOutcome> RegisterDomainOutcomeCallable;
|
|
typedef std::future<RegisterWorkflowTypeOutcome> RegisterWorkflowTypeOutcomeCallable;
|
|
typedef std::future<RequestCancelWorkflowExecutionOutcome> RequestCancelWorkflowExecutionOutcomeCallable;
|
|
typedef std::future<RespondActivityTaskCanceledOutcome> RespondActivityTaskCanceledOutcomeCallable;
|
|
typedef std::future<RespondActivityTaskCompletedOutcome> RespondActivityTaskCompletedOutcomeCallable;
|
|
typedef std::future<RespondActivityTaskFailedOutcome> RespondActivityTaskFailedOutcomeCallable;
|
|
typedef std::future<RespondDecisionTaskCompletedOutcome> RespondDecisionTaskCompletedOutcomeCallable;
|
|
typedef std::future<SignalWorkflowExecutionOutcome> SignalWorkflowExecutionOutcomeCallable;
|
|
typedef std::future<StartWorkflowExecutionOutcome> StartWorkflowExecutionOutcomeCallable;
|
|
typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
|
|
typedef std::future<TerminateWorkflowExecutionOutcome> TerminateWorkflowExecutionOutcomeCallable;
|
|
typedef std::future<UndeprecateActivityTypeOutcome> UndeprecateActivityTypeOutcomeCallable;
|
|
typedef std::future<UndeprecateDomainOutcome> UndeprecateDomainOutcomeCallable;
|
|
typedef std::future<UndeprecateWorkflowTypeOutcome> UndeprecateWorkflowTypeOutcomeCallable;
|
|
typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
|
|
} // namespace Model
|
|
|
|
class SWFClient;
|
|
|
|
typedef std::function<void(const SWFClient*, const Model::CountClosedWorkflowExecutionsRequest&, const Model::CountClosedWorkflowExecutionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CountClosedWorkflowExecutionsResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::CountOpenWorkflowExecutionsRequest&, const Model::CountOpenWorkflowExecutionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CountOpenWorkflowExecutionsResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::CountPendingActivityTasksRequest&, const Model::CountPendingActivityTasksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CountPendingActivityTasksResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::CountPendingDecisionTasksRequest&, const Model::CountPendingDecisionTasksOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CountPendingDecisionTasksResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DeprecateActivityTypeRequest&, const Model::DeprecateActivityTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeprecateActivityTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DeprecateDomainRequest&, const Model::DeprecateDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeprecateDomainResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DeprecateWorkflowTypeRequest&, const Model::DeprecateWorkflowTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeprecateWorkflowTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DescribeActivityTypeRequest&, const Model::DescribeActivityTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeActivityTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DescribeDomainRequest&, const Model::DescribeDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeDomainResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DescribeWorkflowExecutionRequest&, const Model::DescribeWorkflowExecutionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeWorkflowExecutionResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::DescribeWorkflowTypeRequest&, const Model::DescribeWorkflowTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeWorkflowTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::GetWorkflowExecutionHistoryRequest&, const Model::GetWorkflowExecutionHistoryOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetWorkflowExecutionHistoryResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::ListActivityTypesRequest&, const Model::ListActivityTypesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListActivityTypesResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::ListClosedWorkflowExecutionsRequest&, const Model::ListClosedWorkflowExecutionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListClosedWorkflowExecutionsResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::ListDomainsRequest&, const Model::ListDomainsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListDomainsResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::ListOpenWorkflowExecutionsRequest&, const Model::ListOpenWorkflowExecutionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListOpenWorkflowExecutionsResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::ListWorkflowTypesRequest&, const Model::ListWorkflowTypesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListWorkflowTypesResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::PollForActivityTaskRequest&, const Model::PollForActivityTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PollForActivityTaskResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::PollForDecisionTaskRequest&, const Model::PollForDecisionTaskOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PollForDecisionTaskResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RecordActivityTaskHeartbeatRequest&, const Model::RecordActivityTaskHeartbeatOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RecordActivityTaskHeartbeatResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RegisterActivityTypeRequest&, const Model::RegisterActivityTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterActivityTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RegisterDomainRequest&, const Model::RegisterDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterDomainResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RegisterWorkflowTypeRequest&, const Model::RegisterWorkflowTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterWorkflowTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RequestCancelWorkflowExecutionRequest&, const Model::RequestCancelWorkflowExecutionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RequestCancelWorkflowExecutionResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RespondActivityTaskCanceledRequest&, const Model::RespondActivityTaskCanceledOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RespondActivityTaskCanceledResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RespondActivityTaskCompletedRequest&, const Model::RespondActivityTaskCompletedOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RespondActivityTaskCompletedResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RespondActivityTaskFailedRequest&, const Model::RespondActivityTaskFailedOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RespondActivityTaskFailedResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::RespondDecisionTaskCompletedRequest&, const Model::RespondDecisionTaskCompletedOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RespondDecisionTaskCompletedResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::SignalWorkflowExecutionRequest&, const Model::SignalWorkflowExecutionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SignalWorkflowExecutionResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::StartWorkflowExecutionRequest&, const Model::StartWorkflowExecutionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartWorkflowExecutionResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::TerminateWorkflowExecutionRequest&, const Model::TerminateWorkflowExecutionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TerminateWorkflowExecutionResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::UndeprecateActivityTypeRequest&, const Model::UndeprecateActivityTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UndeprecateActivityTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::UndeprecateDomainRequest&, const Model::UndeprecateDomainOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UndeprecateDomainResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::UndeprecateWorkflowTypeRequest&, const Model::UndeprecateWorkflowTypeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UndeprecateWorkflowTypeResponseReceivedHandler;
|
|
typedef std::function<void(const SWFClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
|
|
|
|
/**
|
|
* <fullname>Amazon Simple Workflow Service</fullname> <p>The Amazon Simple
|
|
* Workflow Service (Amazon SWF) makes it easy to build applications that use
|
|
* Amazon's cloud to coordinate work across distributed components. In Amazon SWF,
|
|
* a <i>task</i> represents a logical unit of work that is performed by a component
|
|
* of your workflow. Coordinating tasks in a workflow involves managing intertask
|
|
* dependencies, scheduling, and concurrency in accordance with the logical flow of
|
|
* the application.</p> <p>Amazon SWF gives you full control over implementing
|
|
* tasks and coordinating them without worrying about underlying complexities such
|
|
* as tracking their progress and maintaining their state.</p> <p>This
|
|
* documentation serves as reference only. For a broader overview of the Amazon SWF
|
|
* programming model, see the <i> <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/">Amazon SWF
|
|
* Developer Guide</a> </i>.</p>
|
|
*/
|
|
class AWS_SWF_API SWFClient : public Aws::Client::AWSJsonClient
|
|
{
|
|
public:
|
|
typedef Aws::Client::AWSJsonClient BASECLASS;
|
|
|
|
/**
|
|
* Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
|
|
* is not specified, it will be initialized to default values.
|
|
*/
|
|
SWFClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
|
|
|
|
/**
|
|
* Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
|
|
* is not specified, it will be initialized to default values.
|
|
*/
|
|
SWFClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
|
|
|
|
/**
|
|
* Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
|
|
* the default http client factory will be used
|
|
*/
|
|
SWFClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
|
|
const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
|
|
|
|
virtual ~SWFClient();
|
|
|
|
|
|
/**
|
|
* <p>Returns the number of closed workflow executions within the given domain that
|
|
* meet the specified filtering criteria.</p> <p>This operation is
|
|
* eventually consistent. The results are best effort and may not exactly reflect
|
|
* recent updates and changes.</p> <p> <b>Access Control</b> </p> <p>You
|
|
* can use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagFilter.tag</code>: String constraint. The key is
|
|
* <code>swf:tagFilter.tag</code>.</p> </li> <li> <p> <code>typeFilter.name</code>:
|
|
* String constraint. The key is <code>swf:typeFilter.name</code>.</p> </li> <li>
|
|
* <p> <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountClosedWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::CountClosedWorkflowExecutionsOutcome CountClosedWorkflowExecutions(const Model::CountClosedWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the number of closed workflow executions within the given domain that
|
|
* meet the specified filtering criteria.</p> <p>This operation is
|
|
* eventually consistent. The results are best effort and may not exactly reflect
|
|
* recent updates and changes.</p> <p> <b>Access Control</b> </p> <p>You
|
|
* can use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagFilter.tag</code>: String constraint. The key is
|
|
* <code>swf:tagFilter.tag</code>.</p> </li> <li> <p> <code>typeFilter.name</code>:
|
|
* String constraint. The key is <code>swf:typeFilter.name</code>.</p> </li> <li>
|
|
* <p> <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountClosedWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::CountClosedWorkflowExecutionsOutcomeCallable CountClosedWorkflowExecutionsCallable(const Model::CountClosedWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the number of closed workflow executions within the given domain that
|
|
* meet the specified filtering criteria.</p> <p>This operation is
|
|
* eventually consistent. The results are best effort and may not exactly reflect
|
|
* recent updates and changes.</p> <p> <b>Access Control</b> </p> <p>You
|
|
* can use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagFilter.tag</code>: String constraint. The key is
|
|
* <code>swf:tagFilter.tag</code>.</p> </li> <li> <p> <code>typeFilter.name</code>:
|
|
* String constraint. The key is <code>swf:typeFilter.name</code>.</p> </li> <li>
|
|
* <p> <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountClosedWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void CountClosedWorkflowExecutionsAsync(const Model::CountClosedWorkflowExecutionsRequest& request, const CountClosedWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns the number of open workflow executions within the given domain that
|
|
* meet the specified filtering criteria.</p> <p>This operation is
|
|
* eventually consistent. The results are best effort and may not exactly reflect
|
|
* recent updates and changes.</p> <p> <b>Access Control</b> </p> <p>You
|
|
* can use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagFilter.tag</code>: String constraint. The key is
|
|
* <code>swf:tagFilter.tag</code>.</p> </li> <li> <p> <code>typeFilter.name</code>:
|
|
* String constraint. The key is <code>swf:typeFilter.name</code>.</p> </li> <li>
|
|
* <p> <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountOpenWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::CountOpenWorkflowExecutionsOutcome CountOpenWorkflowExecutions(const Model::CountOpenWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the number of open workflow executions within the given domain that
|
|
* meet the specified filtering criteria.</p> <p>This operation is
|
|
* eventually consistent. The results are best effort and may not exactly reflect
|
|
* recent updates and changes.</p> <p> <b>Access Control</b> </p> <p>You
|
|
* can use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagFilter.tag</code>: String constraint. The key is
|
|
* <code>swf:tagFilter.tag</code>.</p> </li> <li> <p> <code>typeFilter.name</code>:
|
|
* String constraint. The key is <code>swf:typeFilter.name</code>.</p> </li> <li>
|
|
* <p> <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountOpenWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::CountOpenWorkflowExecutionsOutcomeCallable CountOpenWorkflowExecutionsCallable(const Model::CountOpenWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the number of open workflow executions within the given domain that
|
|
* meet the specified filtering criteria.</p> <p>This operation is
|
|
* eventually consistent. The results are best effort and may not exactly reflect
|
|
* recent updates and changes.</p> <p> <b>Access Control</b> </p> <p>You
|
|
* can use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagFilter.tag</code>: String constraint. The key is
|
|
* <code>swf:tagFilter.tag</code>.</p> </li> <li> <p> <code>typeFilter.name</code>:
|
|
* String constraint. The key is <code>swf:typeFilter.name</code>.</p> </li> <li>
|
|
* <p> <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountOpenWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void CountOpenWorkflowExecutionsAsync(const Model::CountOpenWorkflowExecutionsRequest& request, const CountOpenWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns the estimated number of activity tasks in the specified task list.
|
|
* The count returned is an approximation and isn't guaranteed to be exact. If you
|
|
* specify a task list that no activity task was ever scheduled in then
|
|
* <code>0</code> is returned.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the <code>taskList.name</code> parameter by using a
|
|
* <code>Condition</code> element with the <code>swf:taskList.name</code> key to
|
|
* allow the action to access only certain task lists.</p> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountPendingActivityTasks">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::CountPendingActivityTasksOutcome CountPendingActivityTasks(const Model::CountPendingActivityTasksRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the estimated number of activity tasks in the specified task list.
|
|
* The count returned is an approximation and isn't guaranteed to be exact. If you
|
|
* specify a task list that no activity task was ever scheduled in then
|
|
* <code>0</code> is returned.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the <code>taskList.name</code> parameter by using a
|
|
* <code>Condition</code> element with the <code>swf:taskList.name</code> key to
|
|
* allow the action to access only certain task lists.</p> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountPendingActivityTasks">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::CountPendingActivityTasksOutcomeCallable CountPendingActivityTasksCallable(const Model::CountPendingActivityTasksRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the estimated number of activity tasks in the specified task list.
|
|
* The count returned is an approximation and isn't guaranteed to be exact. If you
|
|
* specify a task list that no activity task was ever scheduled in then
|
|
* <code>0</code> is returned.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the <code>taskList.name</code> parameter by using a
|
|
* <code>Condition</code> element with the <code>swf:taskList.name</code> key to
|
|
* allow the action to access only certain task lists.</p> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountPendingActivityTasks">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void CountPendingActivityTasksAsync(const Model::CountPendingActivityTasksRequest& request, const CountPendingActivityTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns the estimated number of decision tasks in the specified task list.
|
|
* The count returned is an approximation and isn't guaranteed to be exact. If you
|
|
* specify a task list that no decision task was ever scheduled in then
|
|
* <code>0</code> is returned.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the <code>taskList.name</code> parameter by using a
|
|
* <code>Condition</code> element with the <code>swf:taskList.name</code> key to
|
|
* allow the action to access only certain task lists.</p> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountPendingDecisionTasks">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::CountPendingDecisionTasksOutcome CountPendingDecisionTasks(const Model::CountPendingDecisionTasksRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the estimated number of decision tasks in the specified task list.
|
|
* The count returned is an approximation and isn't guaranteed to be exact. If you
|
|
* specify a task list that no decision task was ever scheduled in then
|
|
* <code>0</code> is returned.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the <code>taskList.name</code> parameter by using a
|
|
* <code>Condition</code> element with the <code>swf:taskList.name</code> key to
|
|
* allow the action to access only certain task lists.</p> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountPendingDecisionTasks">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::CountPendingDecisionTasksOutcomeCallable CountPendingDecisionTasksCallable(const Model::CountPendingDecisionTasksRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the estimated number of decision tasks in the specified task list.
|
|
* The count returned is an approximation and isn't guaranteed to be exact. If you
|
|
* specify a task list that no decision task was ever scheduled in then
|
|
* <code>0</code> is returned.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the <code>taskList.name</code> parameter by using a
|
|
* <code>Condition</code> element with the <code>swf:taskList.name</code> key to
|
|
* allow the action to access only certain task lists.</p> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/CountPendingDecisionTasks">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void CountPendingDecisionTasksAsync(const Model::CountPendingDecisionTasksRequest& request, const CountPendingDecisionTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified <i>activity type</i>. After an activity type has
|
|
* been deprecated, you cannot create new tasks of that activity type. Tasks of
|
|
* this type that were scheduled before the type was deprecated continue to
|
|
* run.</p> <p>This operation is eventually consistent. The results are best
|
|
* effort and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>activityType.name</code>: String
|
|
* constraint. The key is <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateActivityType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DeprecateActivityTypeOutcome DeprecateActivityType(const Model::DeprecateActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified <i>activity type</i>. After an activity type has
|
|
* been deprecated, you cannot create new tasks of that activity type. Tasks of
|
|
* this type that were scheduled before the type was deprecated continue to
|
|
* run.</p> <p>This operation is eventually consistent. The results are best
|
|
* effort and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>activityType.name</code>: String
|
|
* constraint. The key is <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DeprecateActivityTypeOutcomeCallable DeprecateActivityTypeCallable(const Model::DeprecateActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified <i>activity type</i>. After an activity type has
|
|
* been deprecated, you cannot create new tasks of that activity type. Tasks of
|
|
* this type that were scheduled before the type was deprecated continue to
|
|
* run.</p> <p>This operation is eventually consistent. The results are best
|
|
* effort and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>activityType.name</code>: String
|
|
* constraint. The key is <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DeprecateActivityTypeAsync(const Model::DeprecateActivityTypeRequest& request, const DeprecateActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified domain. After a domain has been deprecated it cannot
|
|
* be used to create new workflow executions or register new types. However, you
|
|
* can still use visibility actions on this domain. Deprecating a domain also
|
|
* deprecates all activity and workflow types registered in the domain. Executions
|
|
* that were started before the domain was deprecated continues to run.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort and may
|
|
* not exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateDomain">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DeprecateDomainOutcome DeprecateDomain(const Model::DeprecateDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified domain. After a domain has been deprecated it cannot
|
|
* be used to create new workflow executions or register new types. However, you
|
|
* can still use visibility actions on this domain. Deprecating a domain also
|
|
* deprecates all activity and workflow types registered in the domain. Executions
|
|
* that were started before the domain was deprecated continues to run.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort and may
|
|
* not exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DeprecateDomainOutcomeCallable DeprecateDomainCallable(const Model::DeprecateDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified domain. After a domain has been deprecated it cannot
|
|
* be used to create new workflow executions or register new types. However, you
|
|
* can still use visibility actions on this domain. Deprecating a domain also
|
|
* deprecates all activity and workflow types registered in the domain. Executions
|
|
* that were started before the domain was deprecated continues to run.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort and may
|
|
* not exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DeprecateDomainAsync(const Model::DeprecateDomainRequest& request, const DeprecateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified <i>workflow type</i>. After a workflow type has been
|
|
* deprecated, you cannot create new executions of that type. Executions that were
|
|
* started before the type was deprecated continues to run. A deprecated workflow
|
|
* type may still be used when calling visibility actions.</p> <p>This
|
|
* operation is eventually consistent. The results are best effort and may not
|
|
* exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>Constrain the following parameters by using
|
|
* a <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DeprecateWorkflowTypeOutcome DeprecateWorkflowType(const Model::DeprecateWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified <i>workflow type</i>. After a workflow type has been
|
|
* deprecated, you cannot create new executions of that type. Executions that were
|
|
* started before the type was deprecated continues to run. A deprecated workflow
|
|
* type may still be used when calling visibility actions.</p> <p>This
|
|
* operation is eventually consistent. The results are best effort and may not
|
|
* exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>Constrain the following parameters by using
|
|
* a <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DeprecateWorkflowTypeOutcomeCallable DeprecateWorkflowTypeCallable(const Model::DeprecateWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Deprecates the specified <i>workflow type</i>. After a workflow type has been
|
|
* deprecated, you cannot create new executions of that type. Executions that were
|
|
* started before the type was deprecated continues to run. A deprecated workflow
|
|
* type may still be used when calling visibility actions.</p> <p>This
|
|
* operation is eventually consistent. The results are best effort and may not
|
|
* exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>Constrain the following parameters by using
|
|
* a <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DeprecateWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DeprecateWorkflowTypeAsync(const Model::DeprecateWorkflowTypeRequest& request, const DeprecateWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified activity type. This includes
|
|
* configuration settings provided when the type was registered and other general
|
|
* information about the type.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>activityType.name</code>: String constraint. The key is
|
|
* <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeActivityType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DescribeActivityTypeOutcome DescribeActivityType(const Model::DescribeActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified activity type. This includes
|
|
* configuration settings provided when the type was registered and other general
|
|
* information about the type.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>activityType.name</code>: String constraint. The key is
|
|
* <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DescribeActivityTypeOutcomeCallable DescribeActivityTypeCallable(const Model::DescribeActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified activity type. This includes
|
|
* configuration settings provided when the type was registered and other general
|
|
* information about the type.</p> <p> <b>Access Control</b> </p> <p>You can use
|
|
* IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>activityType.name</code>: String constraint. The key is
|
|
* <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DescribeActivityTypeAsync(const Model::DescribeActivityTypeRequest& request, const DescribeActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified domain, including description and
|
|
* status.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeDomain">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified domain, including description and
|
|
* status.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const Model::DescribeDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified domain, including description and
|
|
* status.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DescribeDomainAsync(const Model::DescribeDomainRequest& request, const DescribeDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified workflow execution including its type
|
|
* and some statistics.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li> <p>You
|
|
* cannot use an IAM policy to constrain this action's parameters.</p> </li> </ul>
|
|
* <p>If the caller doesn't have sufficient permissions to invoke the action, or
|
|
* the parameter values fall outside the specified constraints, the action fails.
|
|
* The associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DescribeWorkflowExecutionOutcome DescribeWorkflowExecution(const Model::DescribeWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified workflow execution including its type
|
|
* and some statistics.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li> <p>You
|
|
* cannot use an IAM policy to constrain this action's parameters.</p> </li> </ul>
|
|
* <p>If the caller doesn't have sufficient permissions to invoke the action, or
|
|
* the parameter values fall outside the specified constraints, the action fails.
|
|
* The associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DescribeWorkflowExecutionOutcomeCallable DescribeWorkflowExecutionCallable(const Model::DescribeWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified workflow execution including its type
|
|
* and some statistics.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li> <p>You
|
|
* cannot use an IAM policy to constrain this action's parameters.</p> </li> </ul>
|
|
* <p>If the caller doesn't have sufficient permissions to invoke the action, or
|
|
* the parameter values fall outside the specified constraints, the action fails.
|
|
* The associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DescribeWorkflowExecutionAsync(const Model::DescribeWorkflowExecutionRequest& request, const DescribeWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified <i>workflow type</i>. This includes
|
|
* configuration settings specified when the type was registered and other
|
|
* information such as creation date, current status, etc.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>Constrain the following parameters by using
|
|
* a <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::DescribeWorkflowTypeOutcome DescribeWorkflowType(const Model::DescribeWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified <i>workflow type</i>. This includes
|
|
* configuration settings specified when the type was registered and other
|
|
* information such as creation date, current status, etc.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>Constrain the following parameters by using
|
|
* a <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::DescribeWorkflowTypeOutcomeCallable DescribeWorkflowTypeCallable(const Model::DescribeWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about the specified <i>workflow type</i>. This includes
|
|
* configuration settings specified when the type was registered and other
|
|
* information such as creation date, current status, etc.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>Constrain the following parameters by using
|
|
* a <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/DescribeWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void DescribeWorkflowTypeAsync(const Model::DescribeWorkflowTypeRequest& request, const DescribeWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns the history of the specified workflow execution. The results may be
|
|
* split into multiple pages. To retrieve subsequent pages, make the call again
|
|
* using the <code>nextPageToken</code> returned by the initial call.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort and may
|
|
* not exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/GetWorkflowExecutionHistory">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::GetWorkflowExecutionHistoryOutcome GetWorkflowExecutionHistory(const Model::GetWorkflowExecutionHistoryRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the history of the specified workflow execution. The results may be
|
|
* split into multiple pages. To retrieve subsequent pages, make the call again
|
|
* using the <code>nextPageToken</code> returned by the initial call.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort and may
|
|
* not exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/GetWorkflowExecutionHistory">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::GetWorkflowExecutionHistoryOutcomeCallable GetWorkflowExecutionHistoryCallable(const Model::GetWorkflowExecutionHistoryRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the history of the specified workflow execution. The results may be
|
|
* split into multiple pages. To retrieve subsequent pages, make the call again
|
|
* using the <code>nextPageToken</code> returned by the initial call.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort and may
|
|
* not exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/GetWorkflowExecutionHistory">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void GetWorkflowExecutionHistoryAsync(const Model::GetWorkflowExecutionHistoryRequest& request, const GetWorkflowExecutionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns information about all activities registered in the specified domain
|
|
* that match the specified name and registration status. The result includes
|
|
* information like creation date, current status of the activity, etc. The results
|
|
* may be split into multiple pages. To retrieve subsequent pages, make the call
|
|
* again using the <code>nextPageToken</code> returned by the initial call.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListActivityTypes">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::ListActivityTypesOutcome ListActivityTypes(const Model::ListActivityTypesRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about all activities registered in the specified domain
|
|
* that match the specified name and registration status. The result includes
|
|
* information like creation date, current status of the activity, etc. The results
|
|
* may be split into multiple pages. To retrieve subsequent pages, make the call
|
|
* again using the <code>nextPageToken</code> returned by the initial call.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListActivityTypes">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::ListActivityTypesOutcomeCallable ListActivityTypesCallable(const Model::ListActivityTypesRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about all activities registered in the specified domain
|
|
* that match the specified name and registration status. The result includes
|
|
* information like creation date, current status of the activity, etc. The results
|
|
* may be split into multiple pages. To retrieve subsequent pages, make the call
|
|
* again using the <code>nextPageToken</code> returned by the initial call.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListActivityTypes">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void ListActivityTypesAsync(const Model::ListActivityTypesRequest& request, const ListActivityTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns a list of closed workflow executions in the specified domain that
|
|
* meet the filtering criteria. The results may be split into multiple pages. To
|
|
* retrieve subsequent pages, make the call again using the nextPageToken returned
|
|
* by the initial call.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li>
|
|
* <p>Constrain the following parameters by using a <code>Condition</code> element
|
|
* with the appropriate keys.</p> <ul> <li> <p> <code>tagFilter.tag</code>: String
|
|
* constraint. The key is <code>swf:tagFilter.tag</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.name</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.name</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListClosedWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::ListClosedWorkflowExecutionsOutcome ListClosedWorkflowExecutions(const Model::ListClosedWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns a list of closed workflow executions in the specified domain that
|
|
* meet the filtering criteria. The results may be split into multiple pages. To
|
|
* retrieve subsequent pages, make the call again using the nextPageToken returned
|
|
* by the initial call.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li>
|
|
* <p>Constrain the following parameters by using a <code>Condition</code> element
|
|
* with the appropriate keys.</p> <ul> <li> <p> <code>tagFilter.tag</code>: String
|
|
* constraint. The key is <code>swf:tagFilter.tag</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.name</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.name</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListClosedWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::ListClosedWorkflowExecutionsOutcomeCallable ListClosedWorkflowExecutionsCallable(const Model::ListClosedWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns a list of closed workflow executions in the specified domain that
|
|
* meet the filtering criteria. The results may be split into multiple pages. To
|
|
* retrieve subsequent pages, make the call again using the nextPageToken returned
|
|
* by the initial call.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li>
|
|
* <p>Constrain the following parameters by using a <code>Condition</code> element
|
|
* with the appropriate keys.</p> <ul> <li> <p> <code>tagFilter.tag</code>: String
|
|
* constraint. The key is <code>swf:tagFilter.tag</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.name</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.name</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListClosedWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void ListClosedWorkflowExecutionsAsync(const Model::ListClosedWorkflowExecutionsRequest& request, const ListClosedWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns the list of domains registered in the account. The results may be
|
|
* split into multiple pages. To retrieve subsequent pages, make the call again
|
|
* using the nextPageToken returned by the initial call.</p> <p>This
|
|
* operation is eventually consistent. The results are best effort and may not
|
|
* exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains. The
|
|
* element must be set to <code>arn:aws:swf::AccountID:domain/ *</code>, where
|
|
* <i>AccountID</i> is the account ID, with no dashes.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>You cannot use an IAM policy to constrain this action's
|
|
* parameters.</p> </li> </ul> <p>If the caller doesn't have sufficient permissions
|
|
* to invoke the action, or the parameter values fall outside the specified
|
|
* constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListDomains">AWS API
|
|
* Reference</a></p>
|
|
*/
|
|
virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the list of domains registered in the account. The results may be
|
|
* split into multiple pages. To retrieve subsequent pages, make the call again
|
|
* using the nextPageToken returned by the initial call.</p> <p>This
|
|
* operation is eventually consistent. The results are best effort and may not
|
|
* exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains. The
|
|
* element must be set to <code>arn:aws:swf::AccountID:domain/ *</code>, where
|
|
* <i>AccountID</i> is the account ID, with no dashes.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>You cannot use an IAM policy to constrain this action's
|
|
* parameters.</p> </li> </ul> <p>If the caller doesn't have sufficient permissions
|
|
* to invoke the action, or the parameter values fall outside the specified
|
|
* constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListDomains">AWS API
|
|
* Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::ListDomainsOutcomeCallable ListDomainsCallable(const Model::ListDomainsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns the list of domains registered in the account. The results may be
|
|
* split into multiple pages. To retrieve subsequent pages, make the call again
|
|
* using the nextPageToken returned by the initial call.</p> <p>This
|
|
* operation is eventually consistent. The results are best effort and may not
|
|
* exactly reflect recent updates and changes.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains. The
|
|
* element must be set to <code>arn:aws:swf::AccountID:domain/ *</code>, where
|
|
* <i>AccountID</i> is the account ID, with no dashes.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>You cannot use an IAM policy to constrain this action's
|
|
* parameters.</p> </li> </ul> <p>If the caller doesn't have sufficient permissions
|
|
* to invoke the action, or the parameter values fall outside the specified
|
|
* constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListDomains">AWS API
|
|
* Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void ListDomainsAsync(const Model::ListDomainsRequest& request, const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns a list of open workflow executions in the specified domain that meet
|
|
* the filtering criteria. The results may be split into multiple pages. To
|
|
* retrieve subsequent pages, make the call again using the nextPageToken returned
|
|
* by the initial call.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li>
|
|
* <p>Constrain the following parameters by using a <code>Condition</code> element
|
|
* with the appropriate keys.</p> <ul> <li> <p> <code>tagFilter.tag</code>: String
|
|
* constraint. The key is <code>swf:tagFilter.tag</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.name</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.name</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListOpenWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::ListOpenWorkflowExecutionsOutcome ListOpenWorkflowExecutions(const Model::ListOpenWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns a list of open workflow executions in the specified domain that meet
|
|
* the filtering criteria. The results may be split into multiple pages. To
|
|
* retrieve subsequent pages, make the call again using the nextPageToken returned
|
|
* by the initial call.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li>
|
|
* <p>Constrain the following parameters by using a <code>Condition</code> element
|
|
* with the appropriate keys.</p> <ul> <li> <p> <code>tagFilter.tag</code>: String
|
|
* constraint. The key is <code>swf:tagFilter.tag</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.name</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.name</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListOpenWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::ListOpenWorkflowExecutionsOutcomeCallable ListOpenWorkflowExecutionsCallable(const Model::ListOpenWorkflowExecutionsRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns a list of open workflow executions in the specified domain that meet
|
|
* the filtering criteria. The results may be split into multiple pages. To
|
|
* retrieve subsequent pages, make the call again using the nextPageToken returned
|
|
* by the initial call.</p> <p>This operation is eventually consistent. The
|
|
* results are best effort and may not exactly reflect recent updates and
|
|
* changes.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li>
|
|
* <p>Constrain the following parameters by using a <code>Condition</code> element
|
|
* with the appropriate keys.</p> <ul> <li> <p> <code>tagFilter.tag</code>: String
|
|
* constraint. The key is <code>swf:tagFilter.tag</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.name</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.name</code>.</p> </li> <li> <p>
|
|
* <code>typeFilter.version</code>: String constraint. The key is
|
|
* <code>swf:typeFilter.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListOpenWorkflowExecutions">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void ListOpenWorkflowExecutionsAsync(const Model::ListOpenWorkflowExecutionsRequest& request, const ListOpenWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>List tags for a given domain.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListTagsForResource">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
|
|
|
|
/**
|
|
* <p>List tags for a given domain.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListTagsForResource">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const Model::ListTagsForResourceRequest& request) const;
|
|
|
|
/**
|
|
* <p>List tags for a given domain.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListTagsForResource">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void ListTagsForResourceAsync(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Returns information about workflow types in the specified domain. The results
|
|
* may be split into multiple pages that can be retrieved by making the call
|
|
* repeatedly.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListWorkflowTypes">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::ListWorkflowTypesOutcome ListWorkflowTypes(const Model::ListWorkflowTypesRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about workflow types in the specified domain. The results
|
|
* may be split into multiple pages that can be retrieved by making the call
|
|
* repeatedly.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListWorkflowTypes">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::ListWorkflowTypesOutcomeCallable ListWorkflowTypesCallable(const Model::ListWorkflowTypesRequest& request) const;
|
|
|
|
/**
|
|
* <p>Returns information about workflow types in the specified domain. The results
|
|
* may be split into multiple pages that can be retrieved by making the call
|
|
* repeatedly.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/ListWorkflowTypes">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void ListWorkflowTypesAsync(const Model::ListWorkflowTypesRequest& request, const ListWorkflowTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by workers to get an <a>ActivityTask</a> from the specified activity
|
|
* <code>taskList</code>. This initiates a long poll, where the service holds the
|
|
* HTTP connection open and responds as soon as a task becomes available. The
|
|
* maximum time the service holds on to the request before responding is 60
|
|
* seconds. If no task is available within 60 seconds, the poll returns an empty
|
|
* result. An empty result, in this context, means that an ActivityTask is
|
|
* returned, but that the value of taskToken is an empty string. If a task is
|
|
* returned, the worker should use its type to identify and process it
|
|
* correctly.</p> <p>Workers should set their client side socket
|
|
* timeout to at least 70 seconds (10 seconds higher than the maximum time service
|
|
* may hold the poll request).</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the <code>taskList.name</code> parameter by
|
|
* using a <code>Condition</code> element with the <code>swf:taskList.name</code>
|
|
* key to allow the action to access only certain task lists.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PollForActivityTask">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::PollForActivityTaskOutcome PollForActivityTask(const Model::PollForActivityTaskRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to get an <a>ActivityTask</a> from the specified activity
|
|
* <code>taskList</code>. This initiates a long poll, where the service holds the
|
|
* HTTP connection open and responds as soon as a task becomes available. The
|
|
* maximum time the service holds on to the request before responding is 60
|
|
* seconds. If no task is available within 60 seconds, the poll returns an empty
|
|
* result. An empty result, in this context, means that an ActivityTask is
|
|
* returned, but that the value of taskToken is an empty string. If a task is
|
|
* returned, the worker should use its type to identify and process it
|
|
* correctly.</p> <p>Workers should set their client side socket
|
|
* timeout to at least 70 seconds (10 seconds higher than the maximum time service
|
|
* may hold the poll request).</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the <code>taskList.name</code> parameter by
|
|
* using a <code>Condition</code> element with the <code>swf:taskList.name</code>
|
|
* key to allow the action to access only certain task lists.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PollForActivityTask">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::PollForActivityTaskOutcomeCallable PollForActivityTaskCallable(const Model::PollForActivityTaskRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to get an <a>ActivityTask</a> from the specified activity
|
|
* <code>taskList</code>. This initiates a long poll, where the service holds the
|
|
* HTTP connection open and responds as soon as a task becomes available. The
|
|
* maximum time the service holds on to the request before responding is 60
|
|
* seconds. If no task is available within 60 seconds, the poll returns an empty
|
|
* result. An empty result, in this context, means that an ActivityTask is
|
|
* returned, but that the value of taskToken is an empty string. If a task is
|
|
* returned, the worker should use its type to identify and process it
|
|
* correctly.</p> <p>Workers should set their client side socket
|
|
* timeout to at least 70 seconds (10 seconds higher than the maximum time service
|
|
* may hold the poll request).</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the <code>taskList.name</code> parameter by
|
|
* using a <code>Condition</code> element with the <code>swf:taskList.name</code>
|
|
* key to allow the action to access only certain task lists.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PollForActivityTask">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void PollForActivityTaskAsync(const Model::PollForActivityTaskRequest& request, const PollForActivityTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by deciders to get a <a>DecisionTask</a> from the specified decision
|
|
* <code>taskList</code>. A decision task may be returned for any open workflow
|
|
* execution that is using the specified task list. The task includes a paginated
|
|
* view of the history of the workflow execution. The decider should use the
|
|
* workflow type and the history to determine how to properly handle the task.</p>
|
|
* <p>This action initiates a long poll, where the service holds the HTTP
|
|
* connection open and responds as soon a task becomes available. If no decision
|
|
* task is available in the specified task list before the timeout of 60 seconds
|
|
* expires, an empty result is returned. An empty result, in this context, means
|
|
* that a DecisionTask is returned, but that the value of taskToken is an empty
|
|
* string.</p> <p>Deciders should set their client side socket timeout
|
|
* to at least 70 seconds (10 seconds higher than the timeout).</p>
|
|
* <p>Because the number of workflow history events for a single
|
|
* workflow execution might be very large, the result returned might be split up
|
|
* across a number of pages. To retrieve subsequent pages, make additional calls to
|
|
* <code>PollForDecisionTask</code> using the <code>nextPageToken</code> returned
|
|
* by the initial call. Note that you do <i>not</i> call
|
|
* <code>GetWorkflowExecutionHistory</code> with this <code>nextPageToken</code>.
|
|
* Instead, call <code>PollForDecisionTask</code> again.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* <code>taskList.name</code> parameter by using a <code>Condition</code> element
|
|
* with the <code>swf:taskList.name</code> key to allow the action to access only
|
|
* certain task lists.</p> </li> </ul> <p>If the caller doesn't have sufficient
|
|
* permissions to invoke the action, or the parameter values fall outside the
|
|
* specified constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PollForDecisionTask">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::PollForDecisionTaskOutcome PollForDecisionTask(const Model::PollForDecisionTaskRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by deciders to get a <a>DecisionTask</a> from the specified decision
|
|
* <code>taskList</code>. A decision task may be returned for any open workflow
|
|
* execution that is using the specified task list. The task includes a paginated
|
|
* view of the history of the workflow execution. The decider should use the
|
|
* workflow type and the history to determine how to properly handle the task.</p>
|
|
* <p>This action initiates a long poll, where the service holds the HTTP
|
|
* connection open and responds as soon a task becomes available. If no decision
|
|
* task is available in the specified task list before the timeout of 60 seconds
|
|
* expires, an empty result is returned. An empty result, in this context, means
|
|
* that a DecisionTask is returned, but that the value of taskToken is an empty
|
|
* string.</p> <p>Deciders should set their client side socket timeout
|
|
* to at least 70 seconds (10 seconds higher than the timeout).</p>
|
|
* <p>Because the number of workflow history events for a single
|
|
* workflow execution might be very large, the result returned might be split up
|
|
* across a number of pages. To retrieve subsequent pages, make additional calls to
|
|
* <code>PollForDecisionTask</code> using the <code>nextPageToken</code> returned
|
|
* by the initial call. Note that you do <i>not</i> call
|
|
* <code>GetWorkflowExecutionHistory</code> with this <code>nextPageToken</code>.
|
|
* Instead, call <code>PollForDecisionTask</code> again.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* <code>taskList.name</code> parameter by using a <code>Condition</code> element
|
|
* with the <code>swf:taskList.name</code> key to allow the action to access only
|
|
* certain task lists.</p> </li> </ul> <p>If the caller doesn't have sufficient
|
|
* permissions to invoke the action, or the parameter values fall outside the
|
|
* specified constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PollForDecisionTask">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::PollForDecisionTaskOutcomeCallable PollForDecisionTaskCallable(const Model::PollForDecisionTaskRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by deciders to get a <a>DecisionTask</a> from the specified decision
|
|
* <code>taskList</code>. A decision task may be returned for any open workflow
|
|
* execution that is using the specified task list. The task includes a paginated
|
|
* view of the history of the workflow execution. The decider should use the
|
|
* workflow type and the history to determine how to properly handle the task.</p>
|
|
* <p>This action initiates a long poll, where the service holds the HTTP
|
|
* connection open and responds as soon a task becomes available. If no decision
|
|
* task is available in the specified task list before the timeout of 60 seconds
|
|
* expires, an empty result is returned. An empty result, in this context, means
|
|
* that a DecisionTask is returned, but that the value of taskToken is an empty
|
|
* string.</p> <p>Deciders should set their client side socket timeout
|
|
* to at least 70 seconds (10 seconds higher than the timeout).</p>
|
|
* <p>Because the number of workflow history events for a single
|
|
* workflow execution might be very large, the result returned might be split up
|
|
* across a number of pages. To retrieve subsequent pages, make additional calls to
|
|
* <code>PollForDecisionTask</code> using the <code>nextPageToken</code> returned
|
|
* by the initial call. Note that you do <i>not</i> call
|
|
* <code>GetWorkflowExecutionHistory</code> with this <code>nextPageToken</code>.
|
|
* Instead, call <code>PollForDecisionTask</code> again.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* <code>taskList.name</code> parameter by using a <code>Condition</code> element
|
|
* with the <code>swf:taskList.name</code> key to allow the action to access only
|
|
* certain task lists.</p> </li> </ul> <p>If the caller doesn't have sufficient
|
|
* permissions to invoke the action, or the parameter values fall outside the
|
|
* specified constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/PollForDecisionTask">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void PollForDecisionTaskAsync(const Model::PollForDecisionTaskRequest& request, const PollForDecisionTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by activity workers to report to the service that the
|
|
* <a>ActivityTask</a> represented by the specified <code>taskToken</code> is still
|
|
* making progress. The worker can also specify details of the progress, for
|
|
* example percent complete, using the <code>details</code> parameter. This action
|
|
* can also be used by the worker as a mechanism to check if cancellation is being
|
|
* requested for the activity task. If a cancellation is being attempted for the
|
|
* specified task, then the boolean <code>cancelRequested</code> flag returned by
|
|
* the service is set to <code>true</code>.</p> <p>This action resets the
|
|
* <code>taskHeartbeatTimeout</code> clock. The <code>taskHeartbeatTimeout</code>
|
|
* is specified in <a>RegisterActivityType</a>.</p> <p>This action doesn't in
|
|
* itself create an event in the workflow execution history. However, if the task
|
|
* times out, the workflow execution history contains a
|
|
* <code>ActivityTaskTimedOut</code> event that contains the information from the
|
|
* last heartbeat generated by the activity worker.</p> <p>The
|
|
* <code>taskStartToCloseTimeout</code> of an activity type is the maximum duration
|
|
* of an activity task, regardless of the number of
|
|
* <a>RecordActivityTaskHeartbeat</a> requests received. The
|
|
* <code>taskStartToCloseTimeout</code> is also specified in
|
|
* <a>RegisterActivityType</a>.</p> <p>This operation is only useful
|
|
* for long-lived activities to report liveliness of the task and to determine if a
|
|
* cancellation is being attempted.</p> <p>If the
|
|
* <code>cancelRequested</code> flag returns <code>true</code>, a cancellation is
|
|
* being attempted. If the worker can cancel the activity, it should respond with
|
|
* <a>RespondActivityTaskCanceled</a>. Otherwise, it should ignore the cancellation
|
|
* request.</p> <p> <b>Access Control</b> </p> <p>You can use IAM
|
|
* policies to control this action's access to Amazon SWF resources as follows:</p>
|
|
* <ul> <li> <p>Use a <code>Resource</code> element with the domain name to limit
|
|
* the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>You cannot use an IAM policy to constrain this action's
|
|
* parameters.</p> </li> </ul> <p>If the caller doesn't have sufficient permissions
|
|
* to invoke the action, or the parameter values fall outside the specified
|
|
* constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RecordActivityTaskHeartbeat">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RecordActivityTaskHeartbeatOutcome RecordActivityTaskHeartbeat(const Model::RecordActivityTaskHeartbeatRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by activity workers to report to the service that the
|
|
* <a>ActivityTask</a> represented by the specified <code>taskToken</code> is still
|
|
* making progress. The worker can also specify details of the progress, for
|
|
* example percent complete, using the <code>details</code> parameter. This action
|
|
* can also be used by the worker as a mechanism to check if cancellation is being
|
|
* requested for the activity task. If a cancellation is being attempted for the
|
|
* specified task, then the boolean <code>cancelRequested</code> flag returned by
|
|
* the service is set to <code>true</code>.</p> <p>This action resets the
|
|
* <code>taskHeartbeatTimeout</code> clock. The <code>taskHeartbeatTimeout</code>
|
|
* is specified in <a>RegisterActivityType</a>.</p> <p>This action doesn't in
|
|
* itself create an event in the workflow execution history. However, if the task
|
|
* times out, the workflow execution history contains a
|
|
* <code>ActivityTaskTimedOut</code> event that contains the information from the
|
|
* last heartbeat generated by the activity worker.</p> <p>The
|
|
* <code>taskStartToCloseTimeout</code> of an activity type is the maximum duration
|
|
* of an activity task, regardless of the number of
|
|
* <a>RecordActivityTaskHeartbeat</a> requests received. The
|
|
* <code>taskStartToCloseTimeout</code> is also specified in
|
|
* <a>RegisterActivityType</a>.</p> <p>This operation is only useful
|
|
* for long-lived activities to report liveliness of the task and to determine if a
|
|
* cancellation is being attempted.</p> <p>If the
|
|
* <code>cancelRequested</code> flag returns <code>true</code>, a cancellation is
|
|
* being attempted. If the worker can cancel the activity, it should respond with
|
|
* <a>RespondActivityTaskCanceled</a>. Otherwise, it should ignore the cancellation
|
|
* request.</p> <p> <b>Access Control</b> </p> <p>You can use IAM
|
|
* policies to control this action's access to Amazon SWF resources as follows:</p>
|
|
* <ul> <li> <p>Use a <code>Resource</code> element with the domain name to limit
|
|
* the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>You cannot use an IAM policy to constrain this action's
|
|
* parameters.</p> </li> </ul> <p>If the caller doesn't have sufficient permissions
|
|
* to invoke the action, or the parameter values fall outside the specified
|
|
* constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RecordActivityTaskHeartbeat">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RecordActivityTaskHeartbeatOutcomeCallable RecordActivityTaskHeartbeatCallable(const Model::RecordActivityTaskHeartbeatRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by activity workers to report to the service that the
|
|
* <a>ActivityTask</a> represented by the specified <code>taskToken</code> is still
|
|
* making progress. The worker can also specify details of the progress, for
|
|
* example percent complete, using the <code>details</code> parameter. This action
|
|
* can also be used by the worker as a mechanism to check if cancellation is being
|
|
* requested for the activity task. If a cancellation is being attempted for the
|
|
* specified task, then the boolean <code>cancelRequested</code> flag returned by
|
|
* the service is set to <code>true</code>.</p> <p>This action resets the
|
|
* <code>taskHeartbeatTimeout</code> clock. The <code>taskHeartbeatTimeout</code>
|
|
* is specified in <a>RegisterActivityType</a>.</p> <p>This action doesn't in
|
|
* itself create an event in the workflow execution history. However, if the task
|
|
* times out, the workflow execution history contains a
|
|
* <code>ActivityTaskTimedOut</code> event that contains the information from the
|
|
* last heartbeat generated by the activity worker.</p> <p>The
|
|
* <code>taskStartToCloseTimeout</code> of an activity type is the maximum duration
|
|
* of an activity task, regardless of the number of
|
|
* <a>RecordActivityTaskHeartbeat</a> requests received. The
|
|
* <code>taskStartToCloseTimeout</code> is also specified in
|
|
* <a>RegisterActivityType</a>.</p> <p>This operation is only useful
|
|
* for long-lived activities to report liveliness of the task and to determine if a
|
|
* cancellation is being attempted.</p> <p>If the
|
|
* <code>cancelRequested</code> flag returns <code>true</code>, a cancellation is
|
|
* being attempted. If the worker can cancel the activity, it should respond with
|
|
* <a>RespondActivityTaskCanceled</a>. Otherwise, it should ignore the cancellation
|
|
* request.</p> <p> <b>Access Control</b> </p> <p>You can use IAM
|
|
* policies to control this action's access to Amazon SWF resources as follows:</p>
|
|
* <ul> <li> <p>Use a <code>Resource</code> element with the domain name to limit
|
|
* the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>You cannot use an IAM policy to constrain this action's
|
|
* parameters.</p> </li> </ul> <p>If the caller doesn't have sufficient permissions
|
|
* to invoke the action, or the parameter values fall outside the specified
|
|
* constraints, the action fails. The associated event attribute's
|
|
* <code>cause</code> parameter is set to <code>OPERATION_NOT_PERMITTED</code>. For
|
|
* details and example IAM policies, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RecordActivityTaskHeartbeat">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RecordActivityTaskHeartbeatAsync(const Model::RecordActivityTaskHeartbeatRequest& request, const RecordActivityTaskHeartbeatResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Registers a new <i>activity type</i> along with its configuration settings in
|
|
* the specified domain.</p> <p>A <code>TypeAlreadyExists</code> fault
|
|
* is returned if the type already exists in the domain. You cannot change any
|
|
* configuration settings of the type after its registration, and it must be
|
|
* registered as a new version.</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>defaultTaskList.name</code>: String constraint. The key is
|
|
* <code>swf:defaultTaskList.name</code>.</p> </li> <li> <p> <code>name</code>:
|
|
* String constraint. The key is <code>swf:name</code>.</p> </li> <li> <p>
|
|
* <code>version</code>: String constraint. The key is
|
|
* <code>swf:version</code>.</p> </li> </ul> </li> </ul> <p>If the caller doesn't
|
|
* have sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterActivityType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RegisterActivityTypeOutcome RegisterActivityType(const Model::RegisterActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Registers a new <i>activity type</i> along with its configuration settings in
|
|
* the specified domain.</p> <p>A <code>TypeAlreadyExists</code> fault
|
|
* is returned if the type already exists in the domain. You cannot change any
|
|
* configuration settings of the type after its registration, and it must be
|
|
* registered as a new version.</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>defaultTaskList.name</code>: String constraint. The key is
|
|
* <code>swf:defaultTaskList.name</code>.</p> </li> <li> <p> <code>name</code>:
|
|
* String constraint. The key is <code>swf:name</code>.</p> </li> <li> <p>
|
|
* <code>version</code>: String constraint. The key is
|
|
* <code>swf:version</code>.</p> </li> </ul> </li> </ul> <p>If the caller doesn't
|
|
* have sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RegisterActivityTypeOutcomeCallable RegisterActivityTypeCallable(const Model::RegisterActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Registers a new <i>activity type</i> along with its configuration settings in
|
|
* the specified domain.</p> <p>A <code>TypeAlreadyExists</code> fault
|
|
* is returned if the type already exists in the domain. You cannot change any
|
|
* configuration settings of the type after its registration, and it must be
|
|
* registered as a new version.</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>defaultTaskList.name</code>: String constraint. The key is
|
|
* <code>swf:defaultTaskList.name</code>.</p> </li> <li> <p> <code>name</code>:
|
|
* String constraint. The key is <code>swf:name</code>.</p> </li> <li> <p>
|
|
* <code>version</code>: String constraint. The key is
|
|
* <code>swf:version</code>.</p> </li> </ul> </li> </ul> <p>If the caller doesn't
|
|
* have sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RegisterActivityTypeAsync(const Model::RegisterActivityTypeRequest& request, const RegisterActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Registers a new domain.</p> <p> <b>Access Control</b> </p> <p>You can use IAM
|
|
* policies to control this action's access to Amazon SWF resources as follows:</p>
|
|
* <ul> <li> <p>You cannot use an IAM policy to control domain access for this
|
|
* action. The name of the domain being registered is available as the resource of
|
|
* this action.</p> </li> <li> <p>Use an <code>Action</code> element to allow or
|
|
* deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterDomain">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RegisterDomainOutcome RegisterDomain(const Model::RegisterDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Registers a new domain.</p> <p> <b>Access Control</b> </p> <p>You can use IAM
|
|
* policies to control this action's access to Amazon SWF resources as follows:</p>
|
|
* <ul> <li> <p>You cannot use an IAM policy to control domain access for this
|
|
* action. The name of the domain being registered is available as the resource of
|
|
* this action.</p> </li> <li> <p>Use an <code>Action</code> element to allow or
|
|
* deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RegisterDomainOutcomeCallable RegisterDomainCallable(const Model::RegisterDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Registers a new domain.</p> <p> <b>Access Control</b> </p> <p>You can use IAM
|
|
* policies to control this action's access to Amazon SWF resources as follows:</p>
|
|
* <ul> <li> <p>You cannot use an IAM policy to control domain access for this
|
|
* action. The name of the domain being registered is available as the resource of
|
|
* this action.</p> </li> <li> <p>Use an <code>Action</code> element to allow or
|
|
* deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RegisterDomainAsync(const Model::RegisterDomainRequest& request, const RegisterDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Registers a new <i>workflow type</i> and its configuration settings in the
|
|
* specified domain.</p> <p>The retention period for the workflow history is set by
|
|
* the <a>RegisterDomain</a> action.</p> <p>If the type already exists,
|
|
* then a <code>TypeAlreadyExists</code> fault is returned. You cannot change the
|
|
* configuration settings of a workflow type once it is registered and it must be
|
|
* registered as a new version.</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>defaultTaskList.name</code>: String constraint. The key is
|
|
* <code>swf:defaultTaskList.name</code>.</p> </li> <li> <p> <code>name</code>:
|
|
* String constraint. The key is <code>swf:name</code>.</p> </li> <li> <p>
|
|
* <code>version</code>: String constraint. The key is
|
|
* <code>swf:version</code>.</p> </li> </ul> </li> </ul> <p>If the caller doesn't
|
|
* have sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RegisterWorkflowTypeOutcome RegisterWorkflowType(const Model::RegisterWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Registers a new <i>workflow type</i> and its configuration settings in the
|
|
* specified domain.</p> <p>The retention period for the workflow history is set by
|
|
* the <a>RegisterDomain</a> action.</p> <p>If the type already exists,
|
|
* then a <code>TypeAlreadyExists</code> fault is returned. You cannot change the
|
|
* configuration settings of a workflow type once it is registered and it must be
|
|
* registered as a new version.</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>defaultTaskList.name</code>: String constraint. The key is
|
|
* <code>swf:defaultTaskList.name</code>.</p> </li> <li> <p> <code>name</code>:
|
|
* String constraint. The key is <code>swf:name</code>.</p> </li> <li> <p>
|
|
* <code>version</code>: String constraint. The key is
|
|
* <code>swf:version</code>.</p> </li> </ul> </li> </ul> <p>If the caller doesn't
|
|
* have sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RegisterWorkflowTypeOutcomeCallable RegisterWorkflowTypeCallable(const Model::RegisterWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Registers a new <i>workflow type</i> and its configuration settings in the
|
|
* specified domain.</p> <p>The retention period for the workflow history is set by
|
|
* the <a>RegisterDomain</a> action.</p> <p>If the type already exists,
|
|
* then a <code>TypeAlreadyExists</code> fault is returned. You cannot change the
|
|
* configuration settings of a workflow type once it is registered and it must be
|
|
* registered as a new version.</p> <p> <b>Access Control</b> </p>
|
|
* <p>You can use IAM policies to control this action's access to Amazon SWF
|
|
* resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with
|
|
* the domain name to limit the action to only specified domains.</p> </li> <li>
|
|
* <p>Use an <code>Action</code> element to allow or deny permission to call this
|
|
* action.</p> </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>defaultTaskList.name</code>: String constraint. The key is
|
|
* <code>swf:defaultTaskList.name</code>.</p> </li> <li> <p> <code>name</code>:
|
|
* String constraint. The key is <code>swf:name</code>.</p> </li> <li> <p>
|
|
* <code>version</code>: String constraint. The key is
|
|
* <code>swf:version</code>.</p> </li> </ul> </li> </ul> <p>If the caller doesn't
|
|
* have sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RegisterWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RegisterWorkflowTypeAsync(const Model::RegisterWorkflowTypeRequest& request, const RegisterWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionCancelRequested</code> event in the
|
|
* currently running workflow execution identified by the given domain, workflowId,
|
|
* and runId. This logically requests the cancellation of the workflow execution as
|
|
* a whole. It is up to the decider to take appropriate actions when it receives an
|
|
* execution history with this event.</p> <p>If the runId isn't specified,
|
|
* the <code>WorkflowExecutionCancelRequested</code> event is recorded in the
|
|
* history of the current open workflow execution with the specified workflowId in
|
|
* the domain.</p> <p>Because this action allows the workflow to
|
|
* properly clean up and gracefully close, it should be used instead of
|
|
* <a>TerminateWorkflowExecution</a> when possible.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RequestCancelWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RequestCancelWorkflowExecutionOutcome RequestCancelWorkflowExecution(const Model::RequestCancelWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionCancelRequested</code> event in the
|
|
* currently running workflow execution identified by the given domain, workflowId,
|
|
* and runId. This logically requests the cancellation of the workflow execution as
|
|
* a whole. It is up to the decider to take appropriate actions when it receives an
|
|
* execution history with this event.</p> <p>If the runId isn't specified,
|
|
* the <code>WorkflowExecutionCancelRequested</code> event is recorded in the
|
|
* history of the current open workflow execution with the specified workflowId in
|
|
* the domain.</p> <p>Because this action allows the workflow to
|
|
* properly clean up and gracefully close, it should be used instead of
|
|
* <a>TerminateWorkflowExecution</a> when possible.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RequestCancelWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RequestCancelWorkflowExecutionOutcomeCallable RequestCancelWorkflowExecutionCallable(const Model::RequestCancelWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionCancelRequested</code> event in the
|
|
* currently running workflow execution identified by the given domain, workflowId,
|
|
* and runId. This logically requests the cancellation of the workflow execution as
|
|
* a whole. It is up to the decider to take appropriate actions when it receives an
|
|
* execution history with this event.</p> <p>If the runId isn't specified,
|
|
* the <code>WorkflowExecutionCancelRequested</code> event is recorded in the
|
|
* history of the current open workflow execution with the specified workflowId in
|
|
* the domain.</p> <p>Because this action allows the workflow to
|
|
* properly clean up and gracefully close, it should be used instead of
|
|
* <a>TerminateWorkflowExecution</a> when possible.</p> <p> <b>Access
|
|
* Control</b> </p> <p>You can use IAM policies to control this action's access to
|
|
* Amazon SWF resources as follows:</p> <ul> <li> <p>Use a <code>Resource</code>
|
|
* element with the domain name to limit the action to only specified domains.</p>
|
|
* </li> <li> <p>Use an <code>Action</code> element to allow or deny permission to
|
|
* call this action.</p> </li> <li> <p>You cannot use an IAM policy to constrain
|
|
* this action's parameters.</p> </li> </ul> <p>If the caller doesn't have
|
|
* sufficient permissions to invoke the action, or the parameter values fall
|
|
* outside the specified constraints, the action fails. The associated event
|
|
* attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RequestCancelWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RequestCancelWorkflowExecutionAsync(const Model::RequestCancelWorkflowExecutionRequest& request, const RequestCancelWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> was successfully canceled. Additional
|
|
* <code>details</code> can be provided using the <code>details</code>
|
|
* argument.</p> <p>These <code>details</code> (if provided) appear in the
|
|
* <code>ActivityTaskCanceled</code> event added to the workflow history.</p>
|
|
* <p>Only use this operation if the <code>canceled</code> flag of a
|
|
* <a>RecordActivityTaskHeartbeat</a> request returns <code>true</code> and if the
|
|
* activity can be safely undone or abandoned.</p> <p>A task is
|
|
* considered open from the time that it is scheduled until it is closed. Therefore
|
|
* a task is reported as open while a worker is processing it. A task is closed
|
|
* after it has been specified in a call to <a>RespondActivityTaskCompleted</a>,
|
|
* RespondActivityTaskCanceled, <a>RespondActivityTaskFailed</a>, or the task has
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskCanceled">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RespondActivityTaskCanceledOutcome RespondActivityTaskCanceled(const Model::RespondActivityTaskCanceledRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> was successfully canceled. Additional
|
|
* <code>details</code> can be provided using the <code>details</code>
|
|
* argument.</p> <p>These <code>details</code> (if provided) appear in the
|
|
* <code>ActivityTaskCanceled</code> event added to the workflow history.</p>
|
|
* <p>Only use this operation if the <code>canceled</code> flag of a
|
|
* <a>RecordActivityTaskHeartbeat</a> request returns <code>true</code> and if the
|
|
* activity can be safely undone or abandoned.</p> <p>A task is
|
|
* considered open from the time that it is scheduled until it is closed. Therefore
|
|
* a task is reported as open while a worker is processing it. A task is closed
|
|
* after it has been specified in a call to <a>RespondActivityTaskCompleted</a>,
|
|
* RespondActivityTaskCanceled, <a>RespondActivityTaskFailed</a>, or the task has
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskCanceled">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RespondActivityTaskCanceledOutcomeCallable RespondActivityTaskCanceledCallable(const Model::RespondActivityTaskCanceledRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> was successfully canceled. Additional
|
|
* <code>details</code> can be provided using the <code>details</code>
|
|
* argument.</p> <p>These <code>details</code> (if provided) appear in the
|
|
* <code>ActivityTaskCanceled</code> event added to the workflow history.</p>
|
|
* <p>Only use this operation if the <code>canceled</code> flag of a
|
|
* <a>RecordActivityTaskHeartbeat</a> request returns <code>true</code> and if the
|
|
* activity can be safely undone or abandoned.</p> <p>A task is
|
|
* considered open from the time that it is scheduled until it is closed. Therefore
|
|
* a task is reported as open while a worker is processing it. A task is closed
|
|
* after it has been specified in a call to <a>RespondActivityTaskCompleted</a>,
|
|
* RespondActivityTaskCanceled, <a>RespondActivityTaskFailed</a>, or the task has
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskCanceled">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RespondActivityTaskCanceledAsync(const Model::RespondActivityTaskCanceledRequest& request, const RespondActivityTaskCanceledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> completed successfully with a <code>result</code>
|
|
* (if provided). The <code>result</code> appears in the
|
|
* <code>ActivityTaskCompleted</code> event in the workflow history.</p>
|
|
* <p>If the requested task doesn't complete successfully, use
|
|
* <a>RespondActivityTaskFailed</a> instead. If the worker finds that the task is
|
|
* canceled through the <code>canceled</code> flag returned by
|
|
* <a>RecordActivityTaskHeartbeat</a>, it should cancel the task, clean up and then
|
|
* call <a>RespondActivityTaskCanceled</a>.</p> <p>A task is
|
|
* considered open from the time that it is scheduled until it is closed. Therefore
|
|
* a task is reported as open while a worker is processing it. A task is closed
|
|
* after it has been specified in a call to RespondActivityTaskCompleted,
|
|
* <a>RespondActivityTaskCanceled</a>, <a>RespondActivityTaskFailed</a>, or the
|
|
* task has <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskCompleted">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RespondActivityTaskCompletedOutcome RespondActivityTaskCompleted(const Model::RespondActivityTaskCompletedRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> completed successfully with a <code>result</code>
|
|
* (if provided). The <code>result</code> appears in the
|
|
* <code>ActivityTaskCompleted</code> event in the workflow history.</p>
|
|
* <p>If the requested task doesn't complete successfully, use
|
|
* <a>RespondActivityTaskFailed</a> instead. If the worker finds that the task is
|
|
* canceled through the <code>canceled</code> flag returned by
|
|
* <a>RecordActivityTaskHeartbeat</a>, it should cancel the task, clean up and then
|
|
* call <a>RespondActivityTaskCanceled</a>.</p> <p>A task is
|
|
* considered open from the time that it is scheduled until it is closed. Therefore
|
|
* a task is reported as open while a worker is processing it. A task is closed
|
|
* after it has been specified in a call to RespondActivityTaskCompleted,
|
|
* <a>RespondActivityTaskCanceled</a>, <a>RespondActivityTaskFailed</a>, or the
|
|
* task has <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskCompleted">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RespondActivityTaskCompletedOutcomeCallable RespondActivityTaskCompletedCallable(const Model::RespondActivityTaskCompletedRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> completed successfully with a <code>result</code>
|
|
* (if provided). The <code>result</code> appears in the
|
|
* <code>ActivityTaskCompleted</code> event in the workflow history.</p>
|
|
* <p>If the requested task doesn't complete successfully, use
|
|
* <a>RespondActivityTaskFailed</a> instead. If the worker finds that the task is
|
|
* canceled through the <code>canceled</code> flag returned by
|
|
* <a>RecordActivityTaskHeartbeat</a>, it should cancel the task, clean up and then
|
|
* call <a>RespondActivityTaskCanceled</a>.</p> <p>A task is
|
|
* considered open from the time that it is scheduled until it is closed. Therefore
|
|
* a task is reported as open while a worker is processing it. A task is closed
|
|
* after it has been specified in a call to RespondActivityTaskCompleted,
|
|
* <a>RespondActivityTaskCanceled</a>, <a>RespondActivityTaskFailed</a>, or the
|
|
* task has <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskCompleted">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RespondActivityTaskCompletedAsync(const Model::RespondActivityTaskCompletedRequest& request, const RespondActivityTaskCompletedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> has failed with <code>reason</code> (if
|
|
* specified). The <code>reason</code> and <code>details</code> appear in the
|
|
* <code>ActivityTaskFailed</code> event added to the workflow history.</p> <p>A
|
|
* task is considered open from the time that it is scheduled until it is closed.
|
|
* Therefore a task is reported as open while a worker is processing it. A task is
|
|
* closed after it has been specified in a call to
|
|
* <a>RespondActivityTaskCompleted</a>, <a>RespondActivityTaskCanceled</a>,
|
|
* RespondActivityTaskFailed, or the task has <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskFailed">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RespondActivityTaskFailedOutcome RespondActivityTaskFailed(const Model::RespondActivityTaskFailedRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> has failed with <code>reason</code> (if
|
|
* specified). The <code>reason</code> and <code>details</code> appear in the
|
|
* <code>ActivityTaskFailed</code> event added to the workflow history.</p> <p>A
|
|
* task is considered open from the time that it is scheduled until it is closed.
|
|
* Therefore a task is reported as open while a worker is processing it. A task is
|
|
* closed after it has been specified in a call to
|
|
* <a>RespondActivityTaskCompleted</a>, <a>RespondActivityTaskCanceled</a>,
|
|
* RespondActivityTaskFailed, or the task has <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskFailed">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RespondActivityTaskFailedOutcomeCallable RespondActivityTaskFailedCallable(const Model::RespondActivityTaskFailedRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by workers to tell the service that the <a>ActivityTask</a> identified
|
|
* by the <code>taskToken</code> has failed with <code>reason</code> (if
|
|
* specified). The <code>reason</code> and <code>details</code> appear in the
|
|
* <code>ActivityTaskFailed</code> event added to the workflow history.</p> <p>A
|
|
* task is considered open from the time that it is scheduled until it is closed.
|
|
* Therefore a task is reported as open while a worker is processing it. A task is
|
|
* closed after it has been specified in a call to
|
|
* <a>RespondActivityTaskCompleted</a>, <a>RespondActivityTaskCanceled</a>,
|
|
* RespondActivityTaskFailed, or the task has <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg-basic.html#swf-dev-timeout-types">timed
|
|
* out</a>.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies to
|
|
* control this action's access to Amazon SWF resources as follows:</p> <ul> <li>
|
|
* <p>Use a <code>Resource</code> element with the domain name to limit the action
|
|
* to only specified domains.</p> </li> <li> <p>Use an <code>Action</code> element
|
|
* to allow or deny permission to call this action.</p> </li> <li> <p>You cannot
|
|
* use an IAM policy to constrain this action's parameters.</p> </li> </ul> <p>If
|
|
* the caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondActivityTaskFailed">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RespondActivityTaskFailedAsync(const Model::RespondActivityTaskFailedRequest& request, const RespondActivityTaskFailedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Used by deciders to tell the service that the <a>DecisionTask</a> identified
|
|
* by the <code>taskToken</code> has successfully completed. The
|
|
* <code>decisions</code> argument specifies the list of decisions made while
|
|
* processing the task.</p> <p>A <code>DecisionTaskCompleted</code> event is added
|
|
* to the workflow history. The <code>executionContext</code> specified is attached
|
|
* to the event in the workflow execution history.</p> <p> <b>Access Control</b>
|
|
* </p> <p>If an IAM policy grants permission to use
|
|
* <code>RespondDecisionTaskCompleted</code>, it can express permissions for the
|
|
* list of decisions in the <code>decisions</code> parameter. Each of the decisions
|
|
* has one or more parameters, much like a regular API call. To allow for policies
|
|
* to be as readable as possible, you can express permissions on decisions as if
|
|
* they were actual API calls, including applying conditions to some parameters.
|
|
* For more information, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondDecisionTaskCompleted">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::RespondDecisionTaskCompletedOutcome RespondDecisionTaskCompleted(const Model::RespondDecisionTaskCompletedRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by deciders to tell the service that the <a>DecisionTask</a> identified
|
|
* by the <code>taskToken</code> has successfully completed. The
|
|
* <code>decisions</code> argument specifies the list of decisions made while
|
|
* processing the task.</p> <p>A <code>DecisionTaskCompleted</code> event is added
|
|
* to the workflow history. The <code>executionContext</code> specified is attached
|
|
* to the event in the workflow execution history.</p> <p> <b>Access Control</b>
|
|
* </p> <p>If an IAM policy grants permission to use
|
|
* <code>RespondDecisionTaskCompleted</code>, it can express permissions for the
|
|
* list of decisions in the <code>decisions</code> parameter. Each of the decisions
|
|
* has one or more parameters, much like a regular API call. To allow for policies
|
|
* to be as readable as possible, you can express permissions on decisions as if
|
|
* they were actual API calls, including applying conditions to some parameters.
|
|
* For more information, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondDecisionTaskCompleted">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::RespondDecisionTaskCompletedOutcomeCallable RespondDecisionTaskCompletedCallable(const Model::RespondDecisionTaskCompletedRequest& request) const;
|
|
|
|
/**
|
|
* <p>Used by deciders to tell the service that the <a>DecisionTask</a> identified
|
|
* by the <code>taskToken</code> has successfully completed. The
|
|
* <code>decisions</code> argument specifies the list of decisions made while
|
|
* processing the task.</p> <p>A <code>DecisionTaskCompleted</code> event is added
|
|
* to the workflow history. The <code>executionContext</code> specified is attached
|
|
* to the event in the workflow execution history.</p> <p> <b>Access Control</b>
|
|
* </p> <p>If an IAM policy grants permission to use
|
|
* <code>RespondDecisionTaskCompleted</code>, it can express permissions for the
|
|
* list of decisions in the <code>decisions</code> parameter. Each of the decisions
|
|
* has one or more parameters, much like a regular API call. To allow for policies
|
|
* to be as readable as possible, you can express permissions on decisions as if
|
|
* they were actual API calls, including applying conditions to some parameters.
|
|
* For more information, see <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/RespondDecisionTaskCompleted">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void RespondDecisionTaskCompletedAsync(const Model::RespondDecisionTaskCompletedRequest& request, const RespondDecisionTaskCompletedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionSignaled</code> event in the workflow
|
|
* execution history and creates a decision task for the workflow execution
|
|
* identified by the given domain, workflowId and runId. The event is recorded with
|
|
* the specified user defined signalName and input (if provided).</p> <p>If
|
|
* a runId isn't specified, then the <code>WorkflowExecutionSignaled</code> event
|
|
* is recorded in the history of the current open workflow with the matching
|
|
* workflowId in the domain.</p> <p>If the specified workflow
|
|
* execution isn't open, this method fails with <code>UnknownResource</code>.</p>
|
|
* <p> <b>Access Control</b> </p> <p>You can use IAM policies to control
|
|
* this action's access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/SignalWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::SignalWorkflowExecutionOutcome SignalWorkflowExecution(const Model::SignalWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionSignaled</code> event in the workflow
|
|
* execution history and creates a decision task for the workflow execution
|
|
* identified by the given domain, workflowId and runId. The event is recorded with
|
|
* the specified user defined signalName and input (if provided).</p> <p>If
|
|
* a runId isn't specified, then the <code>WorkflowExecutionSignaled</code> event
|
|
* is recorded in the history of the current open workflow with the matching
|
|
* workflowId in the domain.</p> <p>If the specified workflow
|
|
* execution isn't open, this method fails with <code>UnknownResource</code>.</p>
|
|
* <p> <b>Access Control</b> </p> <p>You can use IAM policies to control
|
|
* this action's access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/SignalWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::SignalWorkflowExecutionOutcomeCallable SignalWorkflowExecutionCallable(const Model::SignalWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionSignaled</code> event in the workflow
|
|
* execution history and creates a decision task for the workflow execution
|
|
* identified by the given domain, workflowId and runId. The event is recorded with
|
|
* the specified user defined signalName and input (if provided).</p> <p>If
|
|
* a runId isn't specified, then the <code>WorkflowExecutionSignaled</code> event
|
|
* is recorded in the history of the current open workflow with the matching
|
|
* workflowId in the domain.</p> <p>If the specified workflow
|
|
* execution isn't open, this method fails with <code>UnknownResource</code>.</p>
|
|
* <p> <b>Access Control</b> </p> <p>You can use IAM policies to control
|
|
* this action's access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/SignalWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void SignalWorkflowExecutionAsync(const Model::SignalWorkflowExecutionRequest& request, const SignalWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Starts an execution of the workflow type in the specified domain using the
|
|
* provided <code>workflowId</code> and input data.</p> <p>This action returns the
|
|
* newly started workflow execution.</p> <p> <b>Access Control</b> </p> <p>You can
|
|
* use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagList.member.0</code>: The key is <code>swf:tagList.member.0</code>.</p>
|
|
* </li> <li> <p> <code>tagList.member.1</code>: The key is
|
|
* <code>swf:tagList.member.1</code>.</p> </li> <li> <p>
|
|
* <code>tagList.member.2</code>: The key is <code>swf:tagList.member.2</code>.</p>
|
|
* </li> <li> <p> <code>tagList.member.3</code>: The key is
|
|
* <code>swf:tagList.member.3</code>.</p> </li> <li> <p>
|
|
* <code>tagList.member.4</code>: The key is <code>swf:tagList.member.4</code>.</p>
|
|
* </li> <li> <p> <code>taskList</code>: String constraint. The key is
|
|
* <code>swf:taskList.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/StartWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::StartWorkflowExecutionOutcome StartWorkflowExecution(const Model::StartWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Starts an execution of the workflow type in the specified domain using the
|
|
* provided <code>workflowId</code> and input data.</p> <p>This action returns the
|
|
* newly started workflow execution.</p> <p> <b>Access Control</b> </p> <p>You can
|
|
* use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagList.member.0</code>: The key is <code>swf:tagList.member.0</code>.</p>
|
|
* </li> <li> <p> <code>tagList.member.1</code>: The key is
|
|
* <code>swf:tagList.member.1</code>.</p> </li> <li> <p>
|
|
* <code>tagList.member.2</code>: The key is <code>swf:tagList.member.2</code>.</p>
|
|
* </li> <li> <p> <code>tagList.member.3</code>: The key is
|
|
* <code>swf:tagList.member.3</code>.</p> </li> <li> <p>
|
|
* <code>tagList.member.4</code>: The key is <code>swf:tagList.member.4</code>.</p>
|
|
* </li> <li> <p> <code>taskList</code>: String constraint. The key is
|
|
* <code>swf:taskList.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/StartWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::StartWorkflowExecutionOutcomeCallable StartWorkflowExecutionCallable(const Model::StartWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Starts an execution of the workflow type in the specified domain using the
|
|
* provided <code>workflowId</code> and input data.</p> <p>This action returns the
|
|
* newly started workflow execution.</p> <p> <b>Access Control</b> </p> <p>You can
|
|
* use IAM policies to control this action's access to Amazon SWF resources as
|
|
* follows:</p> <ul> <li> <p>Use a <code>Resource</code> element with the domain
|
|
* name to limit the action to only specified domains.</p> </li> <li> <p>Use an
|
|
* <code>Action</code> element to allow or deny permission to call this action.</p>
|
|
* </li> <li> <p>Constrain the following parameters by using a
|
|
* <code>Condition</code> element with the appropriate keys.</p> <ul> <li> <p>
|
|
* <code>tagList.member.0</code>: The key is <code>swf:tagList.member.0</code>.</p>
|
|
* </li> <li> <p> <code>tagList.member.1</code>: The key is
|
|
* <code>swf:tagList.member.1</code>.</p> </li> <li> <p>
|
|
* <code>tagList.member.2</code>: The key is <code>swf:tagList.member.2</code>.</p>
|
|
* </li> <li> <p> <code>tagList.member.3</code>: The key is
|
|
* <code>swf:tagList.member.3</code>.</p> </li> <li> <p>
|
|
* <code>tagList.member.4</code>: The key is <code>swf:tagList.member.4</code>.</p>
|
|
* </li> <li> <p> <code>taskList</code>: String constraint. The key is
|
|
* <code>swf:taskList.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.name</code>: String constraint. The key is
|
|
* <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/StartWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void StartWorkflowExecutionAsync(const Model::StartWorkflowExecutionRequest& request, const StartWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Add a tag to a Amazon SWF domain.</p> <p>Amazon SWF supports a maximum
|
|
* of 50 tags per resource.</p> <p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/TagResource">AWS API
|
|
* Reference</a></p>
|
|
*/
|
|
virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
|
|
|
|
/**
|
|
* <p>Add a tag to a Amazon SWF domain.</p> <p>Amazon SWF supports a maximum
|
|
* of 50 tags per resource.</p> <p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/TagResource">AWS API
|
|
* Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const;
|
|
|
|
/**
|
|
* <p>Add a tag to a Amazon SWF domain.</p> <p>Amazon SWF supports a maximum
|
|
* of 50 tags per resource.</p> <p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/TagResource">AWS API
|
|
* Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionTerminated</code> event and forces closure
|
|
* of the workflow execution identified by the given domain, runId, and workflowId.
|
|
* The child policy, registered with the workflow type or specified when starting
|
|
* this execution, is applied to any open child workflow executions of this
|
|
* workflow execution.</p> <p>If the identified workflow execution was
|
|
* in progress, it is terminated immediately.</p> <p>If a runId
|
|
* isn't specified, then the <code>WorkflowExecutionTerminated</code> event is
|
|
* recorded in the history of the current open workflow with the matching
|
|
* workflowId in the domain.</p> <p>You should consider using
|
|
* <a>RequestCancelWorkflowExecution</a> action instead because it allows the
|
|
* workflow to gracefully close while <a>TerminateWorkflowExecution</a>
|
|
* doesn't.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li> <p>You
|
|
* cannot use an IAM policy to constrain this action's parameters.</p> </li> </ul>
|
|
* <p>If the caller doesn't have sufficient permissions to invoke the action, or
|
|
* the parameter values fall outside the specified constraints, the action fails.
|
|
* The associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/TerminateWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::TerminateWorkflowExecutionOutcome TerminateWorkflowExecution(const Model::TerminateWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionTerminated</code> event and forces closure
|
|
* of the workflow execution identified by the given domain, runId, and workflowId.
|
|
* The child policy, registered with the workflow type or specified when starting
|
|
* this execution, is applied to any open child workflow executions of this
|
|
* workflow execution.</p> <p>If the identified workflow execution was
|
|
* in progress, it is terminated immediately.</p> <p>If a runId
|
|
* isn't specified, then the <code>WorkflowExecutionTerminated</code> event is
|
|
* recorded in the history of the current open workflow with the matching
|
|
* workflowId in the domain.</p> <p>You should consider using
|
|
* <a>RequestCancelWorkflowExecution</a> action instead because it allows the
|
|
* workflow to gracefully close while <a>TerminateWorkflowExecution</a>
|
|
* doesn't.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li> <p>You
|
|
* cannot use an IAM policy to constrain this action's parameters.</p> </li> </ul>
|
|
* <p>If the caller doesn't have sufficient permissions to invoke the action, or
|
|
* the parameter values fall outside the specified constraints, the action fails.
|
|
* The associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/TerminateWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::TerminateWorkflowExecutionOutcomeCallable TerminateWorkflowExecutionCallable(const Model::TerminateWorkflowExecutionRequest& request) const;
|
|
|
|
/**
|
|
* <p>Records a <code>WorkflowExecutionTerminated</code> event and forces closure
|
|
* of the workflow execution identified by the given domain, runId, and workflowId.
|
|
* The child policy, registered with the workflow type or specified when starting
|
|
* this execution, is applied to any open child workflow executions of this
|
|
* workflow execution.</p> <p>If the identified workflow execution was
|
|
* in progress, it is terminated immediately.</p> <p>If a runId
|
|
* isn't specified, then the <code>WorkflowExecutionTerminated</code> event is
|
|
* recorded in the history of the current open workflow with the matching
|
|
* workflowId in the domain.</p> <p>You should consider using
|
|
* <a>RequestCancelWorkflowExecution</a> action instead because it allows the
|
|
* workflow to gracefully close while <a>TerminateWorkflowExecution</a>
|
|
* doesn't.</p> <p> <b>Access Control</b> </p> <p>You can use IAM policies
|
|
* to control this action's access to Amazon SWF resources as follows:</p> <ul>
|
|
* <li> <p>Use a <code>Resource</code> element with the domain name to limit the
|
|
* action to only specified domains.</p> </li> <li> <p>Use an <code>Action</code>
|
|
* element to allow or deny permission to call this action.</p> </li> <li> <p>You
|
|
* cannot use an IAM policy to constrain this action's parameters.</p> </li> </ul>
|
|
* <p>If the caller doesn't have sufficient permissions to invoke the action, or
|
|
* the parameter values fall outside the specified constraints, the action fails.
|
|
* The associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/TerminateWorkflowExecution">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void TerminateWorkflowExecutionAsync(const Model::TerminateWorkflowExecutionRequest& request, const TerminateWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated <i>activity type</i>. After an activity
|
|
* type has been undeprecated, you can create new tasks of that activity type.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort
|
|
* and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>activityType.name</code>: String
|
|
* constraint. The key is <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateActivityType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::UndeprecateActivityTypeOutcome UndeprecateActivityType(const Model::UndeprecateActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated <i>activity type</i>. After an activity
|
|
* type has been undeprecated, you can create new tasks of that activity type.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort
|
|
* and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>activityType.name</code>: String
|
|
* constraint. The key is <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::UndeprecateActivityTypeOutcomeCallable UndeprecateActivityTypeCallable(const Model::UndeprecateActivityTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated <i>activity type</i>. After an activity
|
|
* type has been undeprecated, you can create new tasks of that activity type.</p>
|
|
* <p>This operation is eventually consistent. The results are best effort
|
|
* and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>activityType.name</code>: String
|
|
* constraint. The key is <code>swf:activityType.name</code>.</p> </li> <li> <p>
|
|
* <code>activityType.version</code>: String constraint. The key is
|
|
* <code>swf:activityType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateActivityType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void UndeprecateActivityTypeAsync(const Model::UndeprecateActivityTypeRequest& request, const UndeprecateActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated domain. After a domain has been
|
|
* undeprecated it can be used to create new workflow executions or register new
|
|
* types.</p> <p>This operation is eventually consistent. The results are
|
|
* best effort and may not exactly reflect recent updates and changes.</p>
|
|
* <p> <b>Access Control</b> </p> <p>You can use IAM policies to control this
|
|
* action's access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateDomain">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::UndeprecateDomainOutcome UndeprecateDomain(const Model::UndeprecateDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated domain. After a domain has been
|
|
* undeprecated it can be used to create new workflow executions or register new
|
|
* types.</p> <p>This operation is eventually consistent. The results are
|
|
* best effort and may not exactly reflect recent updates and changes.</p>
|
|
* <p> <b>Access Control</b> </p> <p>You can use IAM policies to control this
|
|
* action's access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::UndeprecateDomainOutcomeCallable UndeprecateDomainCallable(const Model::UndeprecateDomainRequest& request) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated domain. After a domain has been
|
|
* undeprecated it can be used to create new workflow executions or register new
|
|
* types.</p> <p>This operation is eventually consistent. The results are
|
|
* best effort and may not exactly reflect recent updates and changes.</p>
|
|
* <p> <b>Access Control</b> </p> <p>You can use IAM policies to control this
|
|
* action's access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>You cannot use an IAM
|
|
* policy to constrain this action's parameters.</p> </li> </ul> <p>If the caller
|
|
* doesn't have sufficient permissions to invoke the action, or the parameter
|
|
* values fall outside the specified constraints, the action fails. The associated
|
|
* event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateDomain">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void UndeprecateDomainAsync(const Model::UndeprecateDomainRequest& request, const UndeprecateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated <i>workflow type</i>. After a workflow
|
|
* type has been undeprecated, you can create new executions of that type. </p>
|
|
* <p>This operation is eventually consistent. The results are best effort
|
|
* and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>workflowType.name</code>: String
|
|
* constraint. The key is <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::UndeprecateWorkflowTypeOutcome UndeprecateWorkflowType(const Model::UndeprecateWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated <i>workflow type</i>. After a workflow
|
|
* type has been undeprecated, you can create new executions of that type. </p>
|
|
* <p>This operation is eventually consistent. The results are best effort
|
|
* and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>workflowType.name</code>: String
|
|
* constraint. The key is <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::UndeprecateWorkflowTypeOutcomeCallable UndeprecateWorkflowTypeCallable(const Model::UndeprecateWorkflowTypeRequest& request) const;
|
|
|
|
/**
|
|
* <p>Undeprecates a previously deprecated <i>workflow type</i>. After a workflow
|
|
* type has been undeprecated, you can create new executions of that type. </p>
|
|
* <p>This operation is eventually consistent. The results are best effort
|
|
* and may not exactly reflect recent updates and changes.</p> <p>
|
|
* <b>Access Control</b> </p> <p>You can use IAM policies to control this action's
|
|
* access to Amazon SWF resources as follows:</p> <ul> <li> <p>Use a
|
|
* <code>Resource</code> element with the domain name to limit the action to only
|
|
* specified domains.</p> </li> <li> <p>Use an <code>Action</code> element to allow
|
|
* or deny permission to call this action.</p> </li> <li> <p>Constrain the
|
|
* following parameters by using a <code>Condition</code> element with the
|
|
* appropriate keys.</p> <ul> <li> <p> <code>workflowType.name</code>: String
|
|
* constraint. The key is <code>swf:workflowType.name</code>.</p> </li> <li> <p>
|
|
* <code>workflowType.version</code>: String constraint. The key is
|
|
* <code>swf:workflowType.version</code>.</p> </li> </ul> </li> </ul> <p>If the
|
|
* caller doesn't have sufficient permissions to invoke the action, or the
|
|
* parameter values fall outside the specified constraints, the action fails. The
|
|
* associated event attribute's <code>cause</code> parameter is set to
|
|
* <code>OPERATION_NOT_PERMITTED</code>. For details and example IAM policies, see
|
|
* <a
|
|
* href="https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html">Using
|
|
* IAM to Manage Access to Amazon SWF Workflows</a> in the <i>Amazon SWF Developer
|
|
* Guide</i>.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UndeprecateWorkflowType">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void UndeprecateWorkflowTypeAsync(const Model::UndeprecateWorkflowTypeRequest& request, const UndeprecateWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
/**
|
|
* <p>Remove a tag from a Amazon SWF domain.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UntagResource">AWS
|
|
* API Reference</a></p>
|
|
*/
|
|
virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
|
|
|
|
/**
|
|
* <p>Remove a tag from a Amazon SWF domain.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UntagResource">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* returns a future to the operation so that it can be executed in parallel to other requests.
|
|
*/
|
|
virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const;
|
|
|
|
/**
|
|
* <p>Remove a tag from a Amazon SWF domain.</p><p><h3>See Also:</h3> <a
|
|
* href="http://docs.aws.amazon.com/goto/WebAPI/swf-2012-01-25/UntagResource">AWS
|
|
* API Reference</a></p>
|
|
*
|
|
* Queues the request into a thread executor and triggers associated callback when operation has finished.
|
|
*/
|
|
virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
|
|
|
|
|
|
void OverrideEndpoint(const Aws::String& endpoint);
|
|
private:
|
|
void init(const Aws::Client::ClientConfiguration& clientConfiguration);
|
|
void CountClosedWorkflowExecutionsAsyncHelper(const Model::CountClosedWorkflowExecutionsRequest& request, const CountClosedWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void CountOpenWorkflowExecutionsAsyncHelper(const Model::CountOpenWorkflowExecutionsRequest& request, const CountOpenWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void CountPendingActivityTasksAsyncHelper(const Model::CountPendingActivityTasksRequest& request, const CountPendingActivityTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void CountPendingDecisionTasksAsyncHelper(const Model::CountPendingDecisionTasksRequest& request, const CountPendingDecisionTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DeprecateActivityTypeAsyncHelper(const Model::DeprecateActivityTypeRequest& request, const DeprecateActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DeprecateDomainAsyncHelper(const Model::DeprecateDomainRequest& request, const DeprecateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DeprecateWorkflowTypeAsyncHelper(const Model::DeprecateWorkflowTypeRequest& request, const DeprecateWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DescribeActivityTypeAsyncHelper(const Model::DescribeActivityTypeRequest& request, const DescribeActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DescribeDomainAsyncHelper(const Model::DescribeDomainRequest& request, const DescribeDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DescribeWorkflowExecutionAsyncHelper(const Model::DescribeWorkflowExecutionRequest& request, const DescribeWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void DescribeWorkflowTypeAsyncHelper(const Model::DescribeWorkflowTypeRequest& request, const DescribeWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void GetWorkflowExecutionHistoryAsyncHelper(const Model::GetWorkflowExecutionHistoryRequest& request, const GetWorkflowExecutionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void ListActivityTypesAsyncHelper(const Model::ListActivityTypesRequest& request, const ListActivityTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void ListClosedWorkflowExecutionsAsyncHelper(const Model::ListClosedWorkflowExecutionsRequest& request, const ListClosedWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void ListDomainsAsyncHelper(const Model::ListDomainsRequest& request, const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void ListOpenWorkflowExecutionsAsyncHelper(const Model::ListOpenWorkflowExecutionsRequest& request, const ListOpenWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void ListTagsForResourceAsyncHelper(const Model::ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void ListWorkflowTypesAsyncHelper(const Model::ListWorkflowTypesRequest& request, const ListWorkflowTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void PollForActivityTaskAsyncHelper(const Model::PollForActivityTaskRequest& request, const PollForActivityTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void PollForDecisionTaskAsyncHelper(const Model::PollForDecisionTaskRequest& request, const PollForDecisionTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RecordActivityTaskHeartbeatAsyncHelper(const Model::RecordActivityTaskHeartbeatRequest& request, const RecordActivityTaskHeartbeatResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RegisterActivityTypeAsyncHelper(const Model::RegisterActivityTypeRequest& request, const RegisterActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RegisterDomainAsyncHelper(const Model::RegisterDomainRequest& request, const RegisterDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RegisterWorkflowTypeAsyncHelper(const Model::RegisterWorkflowTypeRequest& request, const RegisterWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RequestCancelWorkflowExecutionAsyncHelper(const Model::RequestCancelWorkflowExecutionRequest& request, const RequestCancelWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RespondActivityTaskCanceledAsyncHelper(const Model::RespondActivityTaskCanceledRequest& request, const RespondActivityTaskCanceledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RespondActivityTaskCompletedAsyncHelper(const Model::RespondActivityTaskCompletedRequest& request, const RespondActivityTaskCompletedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RespondActivityTaskFailedAsyncHelper(const Model::RespondActivityTaskFailedRequest& request, const RespondActivityTaskFailedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void RespondDecisionTaskCompletedAsyncHelper(const Model::RespondDecisionTaskCompletedRequest& request, const RespondDecisionTaskCompletedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void SignalWorkflowExecutionAsyncHelper(const Model::SignalWorkflowExecutionRequest& request, const SignalWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void StartWorkflowExecutionAsyncHelper(const Model::StartWorkflowExecutionRequest& request, const StartWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void TerminateWorkflowExecutionAsyncHelper(const Model::TerminateWorkflowExecutionRequest& request, const TerminateWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void UndeprecateActivityTypeAsyncHelper(const Model::UndeprecateActivityTypeRequest& request, const UndeprecateActivityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void UndeprecateDomainAsyncHelper(const Model::UndeprecateDomainRequest& request, const UndeprecateDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void UndeprecateWorkflowTypeAsyncHelper(const Model::UndeprecateWorkflowTypeRequest& request, const UndeprecateWorkflowTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
|
|
|
|
Aws::String m_uri;
|
|
Aws::String m_configScheme;
|
|
std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
|
|
};
|
|
|
|
} // namespace SWF
|
|
} // namespace Aws
|